fix: address 5 issues found in audit review

- prisma-parser: revert implicit M:N detection (riga 122) — cannot
  distinguish 1:N from M:N without two-pass model analysis. Only
  explicit @relation without fields:[] is reliably M:N (riga 102).
- prisma-parser: extractBlocks now strips comments before parsing
  and skips braces inside double-quoted strings (@default("{}"))
- project-analyzer: filter $-prefixed prisma operations from models[]
  ($transaction is not a model name)
- components-generator: replace truncation with skip for long values
  (avoids breaking Markdown with unclosed backticks)
- project-analyzer: handle empty file in lineCount (return 0)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: talionwar

src/analyzers/project-analyzer.ts

@@ -181,9 +181,11 @@ function buildGraph(
             ? 'component'
             : 'lib';
 
-    const lineCount = file.rawContent.endsWith('\n')
-      ? file.rawContent.split('\n').length - 1
-      : file.rawContent.split('\n').length;
+    const lineCount = file.rawContent.length === 0
+      ? 0
+      : file.rawContent.endsWith('\n')
+        ? file.rawContent.split('\n').length - 1
+        : file.rawContent.split('\n').length;
 
     nodes.set(file.relativePath, {
       id: file.relativePath,
@@ -370,7 +372,8 @@ function buildApiRouteInfo(file: ParsedFile, framework: Framework): ApiRouteInfo
   const models: string[] = [];
   const prismaMatch = file.rawContent.matchAll(/prisma\.(\$?\w+)\./g);
   for (const m of prismaMatch) {
-    models.push(m[1]);
+    // Skip client-level operations ($transaction, $queryRaw) — not model names
+    if (!m[1].startsWith('$')) models.push(m[1]);
   }
 
   return {

src/generators/components-generator.ts

@@ -89,10 +89,11 @@ function generateComponentEntry(comp: ComponentInfo, ctx: GeneratorContext): str
   // State
   if (comp.state.length > 0) {
     const stateLines = comp.state.map((s) => {
-      const val = s.initialValue
-        ? ` = ${s.initialValue.replace(/[\n\r]/g, ' ').replace(/\s+/g, ' ').slice(0, 60)}`
-        : '';
-      return `\`${s.name}\`${val}`;
+      if (!s.initialValue) return `\`${s.name}\``;
+      const cleaned = s.initialValue.replace(/[\n\r]/g, ' ').replace(/\s+/g, ' ');
+      // Skip long values entirely to avoid truncating mid-backtick/brace
+      const val = cleaned.length > 50 ? '(...)' : cleaned;
+      return `\`${s.name}\` = ${val}`;
     });
     output += `${bulletList('Internal State', stateLines)}\n`;
   }

src/schema/prisma-parser.ts

@@ -12,20 +12,37 @@ const PRISMA_SCALAR_TYPES = new Set([
   'String', 'Int', 'Float', 'Boolean', 'DateTime', 'Json', 'BigInt', 'Decimal', 'Bytes',
 ]);
 
+/**
+ * Strip comments from Prisma schema content to prevent false matches
+ * in extractBlocks (keywords/braces inside comments)
+ */
+function stripComments(content: string): string {
+  return content
+    .replace(/\/\*[\s\S]*?\*\//g, '')  // multi-line /* */
+    .replace(/\/\/.*$/gm, '');          // single-line //
+}
+
 /**
  * Extract brace-balanced blocks for a given keyword (model, enum, etc.)
  * Handles nested braces correctly — unlike [^}]+ regex which fails on @default({})
+ * Skips braces inside double-quoted strings to handle @default("{}") correctly
  */
-function extractBlocks(content: string, keyword: string): { name: string; body: string }[] {
+function extractBlocks(rawContent: string, keyword: string): { name: string; body: string }[] {
+  const content = stripComments(rawContent);
   const blocks: { name: string; body: string }[] = [];
   const headerRegex = new RegExp(`${keyword}\\s+(\\w+)\\s*\\{`, 'g');
   let match;
   while ((match = headerRegex.exec(content)) !== null) {
     let depth = 1;
     let i = match.index + match[0].length;
+    let inString = false;
     while (i < content.length && depth > 0) {
-      if (content[i] === '{') depth++;
-      else if (content[i] === '}') depth--;
+      if (content[i] === '"' && content[i - 1] !== '\\') {
+        inString = !inString;
+      } else if (!inString) {
+        if (content[i] === '{') depth++;
+        else if (content[i] === '}') depth--;
+      }
       i++;
     }
     if (depth === 0) {
@@ -124,11 +141,13 @@ function parseModelBlock(name: string, body: string, enumNames: Set<string>): Sc
     ) {
       if (!relations.some((r) => r.field === fieldName)) {
         const isArray = line.includes('[]');
-        const isManyToMany = isArray && !line.includes('@relation');
+        // Implicit relations without @relation: default to one-to-many for arrays.
+        // Cannot distinguish 1:N from M:N without checking if target model has FK back.
+        // M:N detection only works reliably on explicit @relation (see riga 102 above).
         relations.push({
           field: fieldName,
           target: fieldType,
-          type: isManyToMany ? 'many-to-many' : isArray ? 'one-to-many' : 'one-to-one',
+          type: isArray ? 'one-to-many' : 'one-to-one',
         });
       }
     }