packages/language-services/src/common/LikeC4.ts (3)

197-202: Consider iterating to count instead of spreading.

Spreading the iterator into an array allocates memory just to get the count. If userDocuments is large, this could be inefficient.

♻️ Alternative using iteration

   documentCount(): number {
-    return [...this.LangiumDocuments.userDocuments].length
+    let count = 0
+    for (const _ of this.LangiumDocuments.userDocuments) {
+      count++
+    }
+    return count
   }

Alternatively, if LangiumDocuments exposes a size or count property on the underlying collection, that would be even better.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/language-services/src/common/LikeC4.ts` around lines 197 - 202, The
documentCount() implementation currently spreads
this.LangiumDocuments.userDocuments into an array which allocates memory; change
it to count via iteration (or use an existing size/length property on the
underlying collection if available) to avoid allocation — iterate
this.LangiumDocuments.userDocuments with a simple counter and return the counter
in documentCount(), referencing the documentCount method and
this.LangiumDocuments.userDocuments when locating the change.

---

21-23: Consider documenting the magic number.

severity === 1 corresponds to DiagnosticSeverity.Error from the LSP specification. A brief comment would improve readability.

📝 Suggested documentation

+/** Checks if a diagnostic is an error (DiagnosticSeverity.Error === 1 in LSP). */
 const isErrorDiagnostic = (diagnostic: { severity?: number }): boolean => {
   return diagnostic.severity === 1
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/language-services/src/common/LikeC4.ts` around lines 21 - 23, The
check in isErrorDiagnostic uses the magic number diagnostic.severity === 1;
replace or document this by referencing the LSP enum (DiagnosticSeverity.Error)
— either import/define a named constant like DiagnosticSeverity.Error and use it
in the comparison, or add a one-line comment above isErrorDiagnostic explaining
that 1 corresponds to DiagnosticSeverity.Error from the LSP spec; update the
function isErrorDiagnostic to use the named constant or include the comment for
clarity.

---

157-161: Use optional chaining for cleaner code.

The static analysis tool correctly identifies that optional chaining would be more concise here.

♻️ Suggested refactor

   hasErrors(): boolean {
-    return this.LangiumDocuments.userDocuments.some(doc => {
-      return doc.diagnostics && doc.diagnostics.some(isErrorDiagnostic)
-    })
+    return this.LangiumDocuments.userDocuments.some(doc =>
+      doc.diagnostics?.some(isErrorDiagnostic) ?? false
+    )
   }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/language-services/src/common/LikeC4.ts` around lines 157 - 161, The
hasErrors() method is verbose; simplify by using optional chaining on
doc.diagnostics when checking for error diagnostics. Update the implementation
in LikeC4.hasErrors to use this.LangiumDocuments.userDocuments.some(doc =>
doc.diagnostics?.some(isErrorDiagnostic)) (or equivalent) so you avoid explicit
&& checks and make the code more concise and readable.

packages/likec4/src/cli/validate/index.ts (1)

145-154: Clarify filteredFiles semantics in stats.

When no file filter is applied, filteredFiles is set to totalFiles (total documents parsed). However, when a filter is applied, filteredFiles is the count of unique files with errors. This asymmetry may confuse consumers of the JSON output.

Consider whether filteredFiles should consistently represent "files with errors" or "files considered in validation."

📝 Option: Consistent "files with errors" semantics

+        const allFileSet = new Set(allErrors.map(e => e.file))
         const filteredFileSet = new Set(filteredErrors.map(e => e.file))

         const result: ValidateResult = {
           valid,
           errors: filteredErrors,
           stats: {
             totalFiles,
             totalErrors,
-            filteredFiles: fileFilter ? filteredFileSet.size : totalFiles,
+            filteredFiles: fileFilter ? filteredFileSet.size : allFileSet.size,
             filteredErrors: filteredErrors.length,
           },
         }

Alternatively, document the current behavior clearly in a JSDoc comment on ValidateResult.stats.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/likec4/src/cli/validate/index.ts` around lines 145 - 154, The stats
field is inconsistent: filteredFiles currently equals totalFiles when no
fileFilter is set but equals the count of unique error files when a filter is
applied; make it consistent by defining filteredFiles to always mean "files with
errors." Update the construction of result.stats in the block that builds
ValidateResult so filteredFiles is always set to filteredFileSet.size (ensure
filteredFileSet is populated with files that have errors regardless of
fileFilter), and add or update a JSDoc on ValidateResult.stats to state that
filteredFiles represents the number of files with validation errors.

packages/language-services/src/common/LikeC4.ts (1)

167-169: Use optional chaining in hasErrors() for cleaner boolean logic.

The current expression works, but optional chaining + nullish coalescing is more idiomatic. Note that the same method (printErrors()) on line 177 already uses this pattern (doc.diagnostics?.filter(isErrorDiagnostic) ?? []).

Proposed diff

   hasErrors(): boolean {
-    return this.LangiumDocuments.userDocuments.some(doc => {
-      return doc.diagnostics && doc.diagnostics.some(isErrorDiagnostic)
-    })
+    return this.LangiumDocuments.userDocuments.some(doc => {
+      return doc.diagnostics?.some(isErrorDiagnostic) ?? false
+    })
   }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/language-services/src/common/LikeC4.ts` around lines 167 - 169, The
hasErrors() method currently uses explicit truthiness checks for
doc.diagnostics; update it to use optional chaining and nullish coalescing like
printErrors() does: inside the arrow passed to
this.LangiumDocuments.userDocuments.some, replace the existing doc.diagnostics
&& doc.diagnostics.some(...) logic with an expression that calls
doc.diagnostics?.some(isErrorDiagnostic) ?? false so missing diagnostics are
treated as false; this keeps behavior identical but uses the more idiomatic
optional chaining pattern.