claudeos-core 1.5.0 → 1.6.0

package/lib/plan-parser.js

@@ -0,0 +1,149 @@
+/**
+ * ClaudeOS-Core — Plan Parser (shared)
+ *
+ * Shared parsing logic for plan files used by both manifest-generator and plan-validator.
+ * Two block formats:
+ *   - <file path="..."> ... </file>   (standard plan format)
+ *   - ## N. `path` \n```markdown ... ```  (code block format, e.g. sync-rules-master)
+ *
+ * Each function accepts a content string and returns parsed blocks.
+ * Replace functions modify content in-place and return the updated string.
+ */
+
+// ─── Extract <file path="..."> blocks ───────────────────────
+
+/**
+ * Parse <file path="..."> ... </file> blocks from plan content.
+ * @param {string} content - plan file content
+ * @param {{ includeContent?: boolean }} options
+ * @returns {Array<{ path: string, content?: string }>}
+ */
+function parseFileBlocks(content, { includeContent = false } = {}) {
+  const result = [];
+  if (includeContent) {
+    const re = /<file\s+path="([^"]+)">\s*\n([\s\S]*?)\n<\/file>/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      result.push({ path: m[1], content: m[2] });
+    }
+  } else {
+    const re = /<file\s+path="([^"]+)">/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      result.push({ path: m[1] });
+    }
+  }
+  return result;
+}
+
+// ─── Extract ## N. `path` ```markdown ... ``` blocks ────────
+
+/**
+ * Parse ## N. `path` + ```markdown ... ``` blocks from plan content.
+ * Uses indexOf-based parsing to correctly handle nested code fences.
+ * @param {string} content - plan file content
+ * @param {{ includeContent?: boolean }} options
+ * @returns {Array<{ path: string, content?: string }>}
+ */
+function parseCodeBlocks(content, { includeContent = false } = {}) {
+  const result = [];
+  const headingRe = includeContent
+    ? /^##\s+\d+\.\s+([^\n]+)/gm
+    : /^##\s+\d+\.\s+`?([^`\n]+)`?/gm;
+  let headingMatch;
+  while ((headingMatch = headingRe.exec(content)) !== null) {
+    const filePath = headingMatch[1].replace(/`/g, "").trim();
+
+    if (!includeContent) {
+      // Path-only mode: just validate and collect
+      if (filePath && filePath.includes("/")) {
+        result.push({ path: filePath });
+      }
+      continue;
+    }
+
+    // Content mode: find opening ```markdown and matching closing ```
+    const openFence = content.indexOf("```markdown\n", headingMatch.index);
+    if (openFence < 0) continue;
+    const contentStart = openFence + "```markdown\n".length;
+    const closingPos = findClosingFence(content, contentStart);
+    if (closingPos < 0) continue;
+    const blockContent = content.substring(contentStart, closingPos).trimEnd();
+    result.push({ path: filePath, content: blockContent });
+    // Advance headingRe past this block to avoid re-matching inside content
+    headingRe.lastIndex = closingPos;
+  }
+  return result;
+}
+
+// ─── Replace <file> block content ───────────────────────────
+
+/**
+ * Replace content inside a <file path="..."> block.
+ * @param {string} content - full plan file content
+ * @param {string} filePath - path attribute to match
+ * @param {string} newContent - replacement content
+ * @returns {string} updated content
+ */
+function replaceFileBlock(content, filePath, newContent) {
+  const escaped = filePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return content.replace(
+    new RegExp(`(<file\\s+path="${escaped}">\\s*\\n)[\\s\\S]*?(\\n</file>)`, "g"),
+    `$1${newContent}$2`
+  );
+}
+
+// ─── Replace code block content ─────────────────────────────
+
+/**
+ * Replace content inside a ## N. `path` ```markdown ... ``` block.
+ * Uses indexOf-based approach to handle nested code fences.
+ * @param {string} content - full plan file content
+ * @param {string} filePath - path to match in heading
+ * @param {string} newContent - replacement content
+ * @returns {string} updated content
+ */
+function replaceCodeBlock(content, filePath, newContent) {
+  const cleanPath = filePath.replace(/`/g, "");
+  const headingPattern = new RegExp(`^##\\s+\\d+\\.\\s+\`?${cleanPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\`?`, "m");
+  const headingMatch = headingPattern.exec(content);
+  if (!headingMatch) return content;
+  const afterHeading = content.indexOf("```markdown\n", headingMatch.index);
+  if (afterHeading < 0) return content;
+  const contentStart = afterHeading + "```markdown\n".length;
+  const closingPos = findClosingFence(content, contentStart);
+  if (closingPos < 0) return content;
+  return content.substring(0, contentStart) + newContent + "\n" + content.substring(closingPos);
+}
+
+// ─── Internal: find closing ``` with nesting ────────────────
+
+function findClosingFence(content, startPos) {
+  let searchPos = startPos;
+  let nestDepth = 0;
+  while (searchPos < content.length) {
+    const nextFence = content.indexOf("\n```", searchPos);
+    if (nextFence < 0) break;
+    const fenceLineStart = nextFence + 1;
+    const nextNewline = content.indexOf("\n", fenceLineStart + 3);
+    const restOfLine = nextNewline >= 0
+      ? content.substring(fenceLineStart + 3, nextNewline)
+      : content.substring(fenceLineStart + 3);
+    const isOpening = /^[a-zA-Z]/.test(restOfLine.trim());
+    if (isOpening) {
+      nestDepth++;
+      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
+    } else if (nestDepth > 0) {
+      nestDepth--;
+      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
+    } else {
+      return fenceLineStart;
+    }
+  }
+  return -1;
+}
+
+// Plan files that use code block format instead of <file> block format
+const CODE_BLOCK_PLANS = ["21.sync-rules-master.md"];
+
+module.exports = { parseFileBlocks, parseCodeBlocks, replaceFileBlock, replaceCodeBlock, CODE_BLOCK_PLANS };

package/lib/safe-fs.js

@@ -50,7 +50,7 @@ function readJsonSafe(filePath, fallback = null) {
 function existsSafe(filePath) {
   try {
     return fs.existsSync(filePath);
-  } catch {
+  } catch (_e) {
     return false;
   }
 }
@@ -95,7 +95,7 @@ function statSafe(filePath) {
       bytes: s.size,
       modified: s.mtime.toISOString().split("T")[0],
     };
-  } catch {
+  } catch (_e) {
     return null;
   }
 }

package/lib/stale-report.js

@@ -0,0 +1,36 @@
+/**
+ * ClaudeOS-Core — Stale Report Utility
+ *
+ * Shared helper for reading/updating claudeos-core/generated/stale-report.json.
+ * Used by: content-validator, sync-checker, plan-validator, health-checker,
+ *          pass-json-validator, manifest-generator.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Update stale-report.json with a new key and optional summary patch.
+ * Reads existing file, merges data, writes back. Safe against missing/malformed files.
+ *
+ * @param {string} genDir - path to claudeos-core/generated/
+ * @param {string} key - top-level key to set (e.g. "contentValidation", "syncMisses")
+ * @param {object} data - value for that key
+ * @param {object} [summaryPatch] - fields to merge into ex.summary
+ */
+function updateStaleReport(genDir, key, data, summaryPatch) {
+  if (!fs.existsSync(genDir)) return;
+  const rp = path.join(genDir, "stale-report.json");
+  let ex = {};
+  if (fs.existsSync(rp)) {
+    try { ex = JSON.parse(fs.readFileSync(rp, "utf-8")); } catch (_e) { ex = {}; }
+  }
+  ex[key] = data;
+  if (summaryPatch) {
+    if (!ex.summary) ex.summary = {};
+    Object.assign(ex.summary, summaryPatch);
+  }
+  fs.writeFileSync(rp, JSON.stringify(ex, null, 2));
+}
+
+module.exports = { updateStaleReport };

package/manifest-generator/index.js

@@ -17,6 +17,8 @@ const fs = require("fs");
 const path = require("path");
 const matter = require("gray-matter");
 const { glob } = require("glob");
+const { parseFileBlocks, parseCodeBlocks, CODE_BLOCK_PLANS } = require("../lib/plan-parser");
+const { updateStaleReport } = require("../lib/stale-report");
 
 const ROOT = process.env.CLAUDEOS_ROOT || path.resolve(__dirname, "../..");
 const GEN = path.join(ROOT, "claudeos-core/generated");
@@ -48,39 +50,23 @@ function stat(f) {
 function frontmatter(f) {
   try {
     return matter(fs.readFileSync(f, "utf-8")).data || {};
-  } catch {
+  } catch (_e) {
     return {};
   }
 }
 
 
-// Plans using <file path="..."> block format
-function extractFileBlocks(f) {
+// Wrappers: read file → parse → attach planFile metadata
+function extractFileBlocksFromFile(f) {
   if (!fs.existsSync(f)) return [];
   const content = fs.readFileSync(f, "utf-8");
-  const result = [];
-  let m;
-  const re = /<file\s+path="([^"]+)">/g;
-  while ((m = re.exec(content)) !== null) {
-    result.push({ sourcePath: m[1], planFile: rel(f) });
-  }
-  return result;
+  return parseFileBlocks(content).map(b => ({ sourcePath: b.path, planFile: rel(f) }));
 }
 
-// Plans using ## N. `path` ```markdown code block format (e.g., 21.sync-rules-master.md)
-function extractCodeBlockPaths(f) {
+function extractCodeBlockPathsFromFile(f) {
   if (!fs.existsSync(f)) return [];
   const content = fs.readFileSync(f, "utf-8");
-  const result = [];
-  const headingRe = /^##\s+\d+\.\s+`?([^`\n]+)`?/gm;
-  let headingMatch;
-  while ((headingMatch = headingRe.exec(content)) !== null) {
-    const filePath = headingMatch[1].trim();
-    if (filePath && filePath.includes("/")) {
-      result.push({ sourcePath: filePath, planFile: rel(f) });
-    }
-  }
-  return result;
+  return parseCodeBlocks(content).map(b => ({ sourcePath: b.path, planFile: rel(f) }));
 }
 
 async function main() {
@@ -136,15 +122,15 @@ async function main() {
   // import-graph.json removed — @import was never a Claude Code feature
 
   // ─── sync-map.json ─────────────────────────────────────
-  const CODE_BLOCK_PLANS = ["21.sync-rules-master.md"];
+  // CODE_BLOCK_PLANS imported from lib/plan-parser.js
   const sm = { generatedAt: new Date().toISOString(), mappings: [] };
   if (fs.existsSync(DIRS.plan)) {
     for (const p of await glob("*.md", { cwd: DIRS.plan, absolute: true })) {
       const bn = path.basename(p);
       if (CODE_BLOCK_PLANS.includes(bn)) {
-        sm.mappings.push(...extractCodeBlockPaths(p));
+        sm.mappings.push(...extractCodeBlockPathsFromFile(p));
       } else {
-        sm.mappings.push(...extractFileBlocks(p));
+        sm.mappings.push(...extractFileBlocksFromFile(p));
       }
     }
   }
@@ -158,7 +144,7 @@ async function main() {
     for (const p of await glob("*.md", { cwd: DIRS.plan, absolute: true })) {
       const r = rel(p);
       const s = stat(p);
-      const blocks = extractFileBlocks(p);
+      const blocks = extractFileBlocksFromFile(p);
       pm.plans.push({ path: r, ...s, fileBlocks: blocks.length, status: "ok" });
     }
   }
@@ -166,16 +152,7 @@ async function main() {
   console.log(`  ✅ plan-manifest.json — ${pm.plans.length} plans`);
 
   // ─── Initialize stale-report.json (preserve existing sub-tool results) ──
-  const srPath = path.join(GEN, "stale-report.json");
-  let sr = {};
-  if (fs.existsSync(srPath)) {
-    try { sr = JSON.parse(fs.readFileSync(srPath, "utf-8")); } catch { sr = {}; }
-  }
-  sr.generatedAt = new Date().toISOString();
-  if (!sr.summary) sr.summary = {};
-  sr.summary.totalIssues = 0;
-  sr.summary.status = "initial";
-  fs.writeFileSync(srPath, JSON.stringify(sr, null, 2));
+  updateStaleReport(GEN, "generatedAt", new Date().toISOString(), { totalIssues: 0, status: "initial" });
   console.log("  ✅ stale-report.json — initialized");
   console.log("\n  📁 Output: claudeos-core/generated/ (4 files)\n");
 }

package/package.json

@@ -1,87 +1,87 @@
-{
-  "name": "claudeos-core",
-  "version": "1.5.0",
-  "description": "Auto-generate Claude Code documentation from your actual source code — Standards, Rules, Skills, and Guides tailored to your project",
-  "main": "bin/cli.js",
-  "bin": {
-    "claudeos-core": "bin/cli.js"
-  },
-  "files": [
-    "bin/",
-    "lib/",
-    "content-validator/",
-    "health-checker/",
-    "manifest-generator/",
-    "pass-json-validator/",
-    "pass-prompts/",
-    "plan-installer/",
-    "plan-validator/",
-    "sync-checker/",
-    "bootstrap.sh",
-    "README.md",
-    "README.ko.md",
-    "LICENSE",
-    "CHANGELOG.md",
-    "CONTRIBUTING.md",
-    "README.zh-CN.md",
-    "README.ja.md",
-    "README.es.md",
-    "README.vi.md",
-    "README.hi.md",
-    "README.ru.md",
-    "README.fr.md",
-    "README.de.md"
-  ],
-  "scripts": {
-    "init": "node bin/cli.js init",
-    "health": "node bin/cli.js health",
-    "validate": "node bin/cli.js validate",
-    "refresh": "node bin/cli.js refresh",
-    "restore": "node bin/cli.js restore",
-    "test": "node --test tests/*.test.js",
-    "test:health": "node health-checker/index.js"
-  },
-  "keywords": [
-    "claude-code",
-    "automation",
-    "code-analysis",
-    "CLAUDE.md",
-    "standards",
-    "rules",
-    "skills",
-    "scaffolding",
-    "i18n",
-    "multi-language",
-    "spring-boot",
-    "kotlin",
-    "exposed",
-    "jooq",
-    "cqrs",
-    "bff",
-    "multi-module",
-    "monorepo",
-    "nextjs",
-    "express",
-    "fastify",
-    "angular",
-    "django",
-    "fastapi"
-  ],
-  "author": "claudeos-core <claudeoscore@gmail.com> (https://github.com/claudeos-core)",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/claudeos-core/claudeos-core.git"
-  },
-  "homepage": "https://github.com/claudeos-core/claudeos-core#readme",
-  "bugs": {
-    "url": "https://github.com/claudeos-core/claudeos-core/issues"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "glob": "^13.0.6",
-    "gray-matter": "^4.0.3"
-  }
-}
+{
+  "name": "claudeos-core",
+  "version": "1.6.0",
+  "description": "Auto-generate Claude Code documentation from your actual source code — Standards, Rules, Skills, and Guides tailored to your project",
+  "main": "bin/cli.js",
+  "bin": {
+    "claudeos-core": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "content-validator/",
+    "health-checker/",
+    "manifest-generator/",
+    "pass-json-validator/",
+    "pass-prompts/",
+    "plan-installer/",
+    "plan-validator/",
+    "sync-checker/",
+    "bootstrap.sh",
+    "README.md",
+    "README.ko.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "README.zh-CN.md",
+    "README.ja.md",
+    "README.es.md",
+    "README.vi.md",
+    "README.hi.md",
+    "README.ru.md",
+    "README.fr.md",
+    "README.de.md"
+  ],
+  "scripts": {
+    "init": "node bin/cli.js init",
+    "health": "node bin/cli.js health",
+    "validate": "node bin/cli.js validate",
+    "refresh": "node bin/cli.js refresh",
+    "restore": "node bin/cli.js restore",
+    "test": "node --test tests/*.test.js",
+    "test:health": "node health-checker/index.js"
+  },
+  "keywords": [
+    "claude-code",
+    "automation",
+    "code-analysis",
+    "CLAUDE.md",
+    "standards",
+    "rules",
+    "skills",
+    "scaffolding",
+    "i18n",
+    "multi-language",
+    "spring-boot",
+    "kotlin",
+    "exposed",
+    "jooq",
+    "cqrs",
+    "bff",
+    "multi-module",
+    "monorepo",
+    "nextjs",
+    "express",
+    "fastify",
+    "angular",
+    "django",
+    "fastapi"
+  ],
+  "author": "claudeos-core <claudeoscore@gmail.com> (https://github.com/claudeos-core)",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/claudeos-core/claudeos-core.git"
+  },
+  "homepage": "https://github.com/claudeos-core/claudeos-core#readme",
+  "bugs": {
+    "url": "https://github.com/claudeos-core/claudeos-core/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "glob": "^13.0.6",
+    "gray-matter": "^4.0.3"
+  }
+}

package/pass-json-validator/index.js

@@ -17,6 +17,7 @@
 const fs = require("fs");
 const path = require("path");
 const { glob } = require("glob");
+const { updateStaleReport } = require("../lib/stale-report");
 
 const ROOT = process.env.CLAUDEOS_ROOT || path.resolve(__dirname, "../..");
 const GEN_DIR = path.join(ROOT, "claudeos-core/generated");
@@ -197,7 +198,7 @@ async function main() {
           isBackend = !frontend || ["express", "nestjs", "django", "fastapi", "spring-boot"].includes(framework);
           isKotlin = language === "kotlin";
           isKotlinCqrs = isKotlin && (architecture === "cqrs" || paData.stack?.multiModule);
-        } catch { /* If project-analysis parsing fails, conservatively assume backend */ }
+        } catch (_e) { /* If project-analysis parsing fails, conservatively assume backend */ }
       }
 
       const sectionsToCheck = [
@@ -282,23 +283,17 @@ async function main() {
   }
 
   // Record in stale-report
-  if (fs.existsSync(GEN_DIR)) {
-    const rp = path.join(GEN_DIR, "stale-report.json");
-    let ex = {};
-    if (fs.existsSync(rp)) {
-      try { ex = JSON.parse(fs.readFileSync(rp, "utf-8")); } catch { ex = {}; }
-    }
-    ex.jsonValidation = { checkedAt: new Date().toISOString(), checked, errors: errors.length, warnings: warnings.length };
-    ex.summary = { ...ex.summary, jsonErrors: errors.length, jsonWarnings: warnings.length };
-    fs.writeFileSync(rp, JSON.stringify(ex, null, 2));
-  }
+  updateStaleReport(GEN_DIR, "jsonValidation",
+    { checkedAt: new Date().toISOString(), checked, errors: errors.length, warnings: warnings.length },
+    { jsonErrors: errors.length, jsonWarnings: warnings.length }
+  );
 
   console.log(`  Total: ${errors.length} errors, ${warnings.length} warnings\n`);
   process.exit(errors.length > 0 ? 1 : 0);
 }
 
 if (require.main === module) {
-  main().catch(console.error);
+  main().catch(e => { console.error(`\n  ❌ Unexpected error: ${e.message || e}`); process.exit(1); });
 }
 
 module.exports = { main };

package/pass-prompts/templates/node-nestjs/pass1.md

@@ -0,0 +1,132 @@
+Read claudeos-core/generated/project-analysis.json and
+perform a deep analysis of the following domains only: {{DOMAIN_GROUP}}
+
+For each domain, select one representative file per layer, read its code, and analyze it.
+Prioritize files with the richest patterns.
+
+Analysis items (per domain):
+
+1. Module & Controller Patterns
+   - @Module() structure (imports, controllers, providers, exports)
+   - @Controller() decorator, route prefix conventions
+   - @Get/@Post/@Put/@Patch/@Delete decorators, parameter decorators (@Body, @Param, @Query, @Headers)
+   - Response handling (@Res() vs return value, interceptors, class-transformer serialization)
+   - If a custom response wrapper/interceptor exists, record its EXACT class name, method signatures, and import path
+   - **Response wrapping layer (CRITICAL)**: Which layer ACTUALLY calls the response wrapper?
+     Does Controller call it directly, or does a Service/UseCase layer return the wrapped response?
+     Record EXACTLY: "Controller wraps response" or "Service wraps response"
+   - If a dedicated orchestration layer exists between Controller and Service (e.g., UseCase, Facade, Aggregator),
+     record its name, responsibilities, and return type
+   - Error handling (HttpException hierarchy, ExceptionFilter, @Catch())
+   - @UseGuards() for authentication (JwtAuthGuard, RolesGuard, custom guards)
+   - API documentation (@ApiTags, @ApiOperation, @ApiResponse, @ApiBearerAuth)
+   - Pagination patterns (offset/limit, cursor, custom)
+   - @Version() API versioning
+
+2. Provider & Service Patterns
+   - @Injectable() and dependency injection (constructor injection, custom providers, useFactory/useClass/useValue)
+   - Module scoping (DEFAULT, REQUEST, TRANSIENT)
+   - Transaction strategy (Prisma.$transaction, TypeORM QueryRunner, Sequelize.transaction)
+   - Business exception handling (custom exception hierarchy extending HttpException)
+   - Validation (@UsePipes, ValidationPipe, class-validator decorators)
+   - Event handling (@OnEvent, EventEmitter2)
+   - CQRS pattern usage (@nestjs/cqrs CommandBus/QueryBus/EventBus)
+
+3. Data Access Patterns
+   - ORM/query builder (Prisma, TypeORM, Sequelize, MikroORM, Mongoose)
+   - Repository pattern (@InjectRepository, custom repository classes)
+   - Query optimization (relations/eager/lazy loading, N+1 prevention)
+   - Migration tools (Prisma Migrate, TypeORM Migration)
+   - Seed data management
+   - Connection management (TypeOrmModule.forRootAsync, PrismaModule)
+
+4. DTO & Validation Patterns
+   - class-validator decorators (@IsString, @IsNotEmpty, @IsEmail, @ValidateNested)
+   - class-transformer decorators (@Expose, @Exclude, @Type, @Transform)
+   - Request/Response DTO separation
+   - Mapped types (PartialType, PickType, OmitType, IntersectionType)
+   - Custom validation decorators
+   - Enum/constants management
+   - File entry pattern: is the main file `index.ts` or named by module (e.g., `users.controller.ts`)? Record exact convention
+   - Import paths: record EXACT path aliases and import patterns (e.g., `@/modules/`, `@app/`, relative paths)
+
+5. Middleware, Guard, Pipe, Interceptor Patterns
+   - @Injectable() middleware (NestMiddleware) vs Express-style middleware
+   - Guards (@CanActivate) — authentication, authorization, role-based
+   - Pipes (ValidationPipe, ParseIntPipe, custom pipes)
+   - Interceptors (logging, caching, timeout, response transformation)
+   - Execution order (middleware → guard → interceptor(pre) → pipe → handler → interceptor(post) → filter)
+
+6. Configuration & Environment Patterns
+   - @nestjs/config (ConfigModule, ConfigService, registerAs)
+   - Environment validation (Joi schema, class-validator)
+   - Per-environment branching (development/staging/production)
+   - Custom configuration namespaces
+
+7. Logging Patterns
+   - NestJS Logger vs external (winston, pino, nestjs-pino)
+   - Log level policy
+   - Structured logging (JSON format, correlation ID)
+   - Request/response logging (LoggingInterceptor)
+
+8. Testing Patterns
+   - Test framework (Jest, Vitest)
+   - Test.createTestingModule() usage
+   - Mocking strategy (jest.mock, overrideProvider, custom TestModule)
+   - E2E testing (supertest, @nestjs/testing)
+   - Test data management (Factory, Fixture, Faker)
+   - DB test strategy (in-memory, test container, separate DB)
+
+9. Domain-Specific Patterns
+   - File upload (@UseInterceptors(FileInterceptor), Multer, S3)
+   - WebSocket (@WebSocketGateway, Socket.io)
+   - Queue/job processing (@nestjs/bull, BullMQ)
+   - External API integration (HttpModule/HttpService, Axios)
+   - Caching (@nestjs/cache-manager, Redis, @CacheKey, @CacheTTL)
+   - Microservices (@nestjs/microservices, Transport)
+   - Scheduling (@nestjs/schedule, @Cron, @Interval)
+   - Health checks (@nestjs/terminus)
+
+10. Anti-patterns / Inconsistencies
+    - Mixing NestJS patterns with raw Express patterns
+    - Business logic in controllers (should be in services)
+    - Circular dependencies
+    - Missing @Injectable() on providers
+    - Type safety issues (any abuse, missing types)
+
+Do not create or modify source files. Analysis only.
+Save results to claudeos-core/generated/pass1-{{PASS_NUM}}.json in the following format:
+
+{
+  "analyzedAt": "ISO timestamp",
+  "passNum": {{PASS_NUM}},
+  "domains": ["users", "auth", "orders", "products"],
+  "analysisPerDomain": {
+    "users": {
+      "representativeFiles": {
+        "module": "users.module.ts",
+        "controller": "users.controller.ts",
+        "service": "users.service.ts",
+        "repository": "users.repository.ts",
+        "dto": "create-user.dto.ts"
+      },
+      "patterns": {
+        "module": { ... },
+        "controller": { ... },
+        "service": { ... },
+        "dataAccess": { ... },
+        "dto": { ... },
+        "middleware": { ... },
+        "config": { ... },
+        "logging": { ... },
+        "testing": { ... }
+      },
+      "specialPatterns": [],
+      "antiPatterns": []
+    }
+  },
+  "crossDomainCommon": {
+    "description": "Patterns commonly used across domains in this group",
+    "patterns": []
+  }
+}