@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.27d5a59

package/codeyam-cli/templates/skills/codeyam-memory/scripts/session-mining/filter-session.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// Session log filter — replaces filter.jq.
+// Strips progress/system/queue records, compresses tool inputs to 300 chars,
+// tool results to 500 chars, thinking to 1000 chars. Output is compact JSONL.
+
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+
+/**
+ * Filter a single parsed session log object.
+ * Returns the filtered object, or null if it should be skipped.
+ */
+export function filterSessionLine(obj) {
+  if (obj.type === 'assistant') {
+    const contentItems = obj.message?.content;
+    if (!Array.isArray(contentItems)) return null;
+
+    const filtered = [];
+    for (const item of contentItems) {
+      if (item.type === 'text') {
+        filtered.push({ t: 'text', text: item.text });
+      } else if (item.type === 'thinking') {
+        const thinking = item.thinking ?? '';
+        filtered.push({
+          t: 'think',
+          thinking: thinking.length > 1000 ? thinking.slice(0, 1000) + '...[truncated]' : thinking,
+        });
+      } else if (item.type === 'tool_use') {
+        const inputStr = typeof item.input === 'string' ? item.input : JSON.stringify(item.input);
+        filtered.push({
+          t: 'tool',
+          name: item.name,
+          input: inputStr.length > 300 ? inputStr.slice(0, 300) + '...' : inputStr,
+        });
+      }
+    }
+
+    return { type: 'assistant', ts: obj.timestamp, content: filtered };
+  }
+
+  if (obj.type === 'user') {
+    const msgContent = obj.message?.content;
+
+    if (typeof msgContent === 'string') {
+      return { type: 'user', ts: obj.timestamp, content: msgContent };
+    }
+
+    if (Array.isArray(msgContent)) {
+      const items = [];
+      for (const item of msgContent) {
+        if (item.type === 'tool_result') {
+          const contentStr = typeof item.content === 'string' ? item.content : JSON.stringify(item.content);
+          items.push({
+            t: 'result',
+            id: item.tool_use_id,
+            err: item.is_error ?? false,
+            content: contentStr.length > 500 ? contentStr.slice(0, 500) + '...[truncated]' : contentStr,
+          });
+        } else {
+          const text = typeof item === 'string' ? item : JSON.stringify(item);
+          items.push({
+            t: 'msg',
+            text: text.length > 500 ? text.slice(0, 500) + '...[truncated]' : text,
+          });
+        }
+      }
+      return { type: 'user', ts: obj.timestamp, content: items };
+    }
+
+    // Fallback: stringify whatever content is
+    const fallback = typeof msgContent === 'string' ? msgContent : JSON.stringify(msgContent);
+    return {
+      type: 'user',
+      ts: obj.timestamp,
+      content: fallback.length > 500 ? fallback.slice(0, 500) + '...[truncated]' : fallback,
+    };
+  }
+
+  return null;
+}
+
+// Standalone mode: node filter-session.mjs input.jsonl → filtered JSONL to stdout
+const inputFile = process.argv[2];
+if (inputFile) {
+  const rl = createInterface({ input: createReadStream(inputFile) });
+  for await (const line of rl) {
+    try {
+      const obj = JSON.parse(line);
+      const result = filterSessionLine(obj);
+      if (result) console.log(JSON.stringify(result));
+    } catch {
+      // Skip malformed lines (matching jq's silent-skip behavior)
+    }
+  }
+}

package/codeyam-cli/templates/skills/codeyam-memory/scripts/session-mining/preprocess.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// Preprocesses Claude Code session logs for the codeyam-memory skill.
+// Replaces preprocess.sh — no jq or platform-specific stat required.
+//
+// - Finds JSONL session files (>=10KB, last 30 days)
+// - Excludes the current active session
+// - Runs JS filter for 5-50x compression
+// - Caches results in /tmp/cc-session-analysis/
+// - Prints filtered file paths to stdout (one per line)
+
+import { readdir, stat, mkdir, readFile, rm } from 'node:fs/promises';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { filterSessionLine } from './filter-session.mjs';
+
+const OUTPUT_DIR = '/tmp/cc-session-analysis';
+const MIN_SIZE = 10240; // 10KB
+const MAX_AGE_DAYS = 30;
+const MAX_SESSIONS = 30;
+const FILTER_TIMEOUT = 30_000; // 30s per file
+
+// Compute Claude project directory (mirrors Claude Code's path hashing)
+const projectDir = process.cwd();
+const projectHash = projectDir.replace(/[/.]/g, '-');
+const sessionDir = join(homedir(), '.claude', 'projects', projectHash);
+
+// Check session directory exists
+try {
+  await stat(sessionDir);
+} catch {
+  process.stderr.write(`No Claude session directory found at ${sessionDir}\n`);
+  process.stderr.write('This project may not have any Claude Code session history.\n');
+  process.exit(0);
+}
+
+// Find eligible session files
+await mkdir(OUTPUT_DIR, { recursive: true });
+
+const entries = await readdir(sessionDir);
+const now = Date.now();
+const maxAgeMs = MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+
+const sessionFiles = [];
+for (const name of entries) {
+  if (!name.endsWith('.jsonl')) continue;
+  const fullPath = join(sessionDir, name);
+  try {
+    const st = await stat(fullPath);
+    if (!st.isFile()) continue;
+    if (st.size < MIN_SIZE) continue;
+    if (now - st.mtimeMs > maxAgeMs) continue;
+    sessionFiles.push({ path: fullPath, mtimeMs: st.mtimeMs });
+  } catch {
+    continue;
+  }
+}
+
+if (sessionFiles.length === 0) process.exit(0);
+
+// Sort newest first, cap to MAX_SESSIONS
+sessionFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
+if (sessionFiles.length > MAX_SESSIONS) {
+  process.stderr.write(`Note: ${sessionFiles.length} sessions found, capping to ${MAX_SESSIONS} most recent\n`);
+}
+const sessions = sessionFiles.slice(0, MAX_SESSIONS);
+
+// Determine active session to exclude
+let activeSession = '';
+const claudeSessionId = process.env.CLAUDE_SESSION_ID;
+if (claudeSessionId) {
+  const match = sessions.find((s) => basename(s.path, '.jsonl') === claudeSessionId);
+  if (match) activeSession = match.path;
+}
+if (!activeSession && sessions.length > 0) {
+  activeSession = sessions[0].path; // newest = likely active
+}
+
+// Process each session
+for (const session of sessions) {
+  if (session.path === activeSession) continue;
+
+  const uuid = basename(session.path, '.jsonl');
+  const filtered = join(OUTPUT_DIR, `${uuid}.filtered.jsonl`);
+
+  // Check cache: skip if filtered file has a valid sentinel
+  try {
+    const firstLine = (await readFile(filtered, 'utf-8')).split('\n')[0];
+    const sentinel = JSON.parse(firstLine);
+    if (sentinel.processed_at) {
+      console.log(filtered);
+      continue;
+    }
+  } catch {
+    // No cache or invalid — reprocess
+  }
+
+  // Filter with timeout
+  try {
+    await filterFile(session.path, filtered);
+    console.log(filtered);
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      process.stderr.write(`Warning: filter timed out after ${FILTER_TIMEOUT / 1000}s on ${basename(session.path)} — skipping\n`);
+      await rm(filtered, { force: true });
+    } else {
+      process.stderr.write(`Warning: error processing ${basename(session.path)}: ${err.message}\n`);
+      await rm(filtered, { force: true });
+    }
+  }
+}
+
+async function filterFile(inputPath, outputPath) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), FILTER_TIMEOUT);
+
+  try {
+    const st = await stat(inputPath);
+    const sentinel = JSON.stringify({
+      processed_at: new Date().toISOString(),
+      source_size: st.size,
+    });
+
+    const output = createWriteStream(outputPath);
+    output.write(sentinel + '\n');
+
+    const rl = createInterface({
+      input: createReadStream(inputPath),
+      signal: ac.signal,
+    });
+
+    let lineCount = 0;
+    for await (const line of rl) {
+      try {
+        const obj = JSON.parse(line);
+        const result = filterSessionLine(obj);
+        if (result) {
+          output.write(JSON.stringify(result) + '\n');
+          lineCount++;
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+
+    output.end();
+    await new Promise((resolve, reject) => {
+      output.on('finish', resolve);
+      output.on('error', reject);
+    });
+
+    // Remove files with no content beyond the sentinel
+    if (lineCount === 0) {
+      await rm(outputPath, { force: true });
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/codeyam-cli/templates/skills/codeyam-new-rule/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: codeyam-new-rule
+autoApprove: true
+description: |
+  Create a new Claude Rule for documenting codebase patterns.
+  Use when: User wants to add documentation for a specific area of the codebase.
+---
+
+# Create New Claude Rule
+
+Read `.codeyam/rules/instructions.md` for detailed guidance on structure and formatting.

package/codeyam-cli/templates/{codeyam:setup.md → skills/codeyam-setup/SKILL.md}

@@ -1,5 +1,5 @@
 ---
-name: codeyam:setup
+name: codeyam-setup
 autoApprove: true
 description: |
   Use this skill when the user asks to "setup CodeYam" or needs to configure CodeYam for their project.
@@ -52,6 +52,18 @@ codeyam validate-mock .codeyam/universal-mocks/{path-to-your-mock}
 
 ## Setup Workflow
 
+### Step 0: Ensure Simulation Infrastructure
+
+Before configuring the dev server or mocks, ensure the simulation infrastructure is installed.
+
+```bash
+codeyam setup-simulations
+```
+
+This is **idempotent** — if already set up, each step is detected and skipped. On first run it installs analyzer dependencies, Playwright chromium, and creates baseline entities (several minutes). Subsequent runs complete in seconds.
+
+If it fails with "No web applications found", the project doesn't support simulations — inform the user and stop.
+
 ### Step 1: Configure Webapp Start Command
 
 **ACTION 1:** Read configuration files:

package/codeyam-cli/templates/{codeyam:sim.md → skills/codeyam-sim/SKILL.md}

@@ -1,5 +1,5 @@
 ---
-name: codeyam:sim
+name: codeyam-sim
 autoApprove: true
 description: |
   Use this skill to create interactive simulations of components and functions using CodeYam's analysis.

package/codeyam-cli/templates/{codeyam:test.md → skills/codeyam-test/SKILL.md}

@@ -1,5 +1,5 @@
 ---
-name: codeyam:test
+name: codeyam-test
 autoApprove: true
 description: |
   Use this skill to write comprehensive unit and integration tests using CodeYam's mock generation.

package/codeyam-cli/templates/{codeyam:verify.md → skills/codeyam-verify/SKILL.md}

@@ -1,5 +1,5 @@
 ---
-name: codeyam:verify
+name: codeyam-verify
 autoApprove: true
 description: |
   Use this skill after making code changes that impact application functionality.

package/package.json

@@ -1,62 +1,67 @@
 {
   "name": "@codeyam/codeyam-cli",
-  "version": "0.1.0-staging.1669d45",
+  "version": "0.1.0-staging.27d5a59",
   "description": "Local development CLI for CodeYam analysis",
   "type": "module",
   "bin": {
     "codeyam": "./codeyam-cli/src/codeyam-cli.js"
   },
   "scripts": {
-    "postinstall": "node ./scripts/finalize-analyzer.cjs"
+    "postinstall": "node ./scripts/npm-post-install.cjs"
   },
   "dependencies": {
-    "@anthropic-ai/claude-code": "^2.0.76",
-    "@anthropic-ai/sdk": "^0.71.0",
-    "@aws-sdk/client-dynamodb": "^3.956.0",
-    "@aws-sdk/s3-request-presigner": "^3.940.0",
-    "@aws-sdk/util-dynamodb": "^3.902.0",
-    "@modelcontextprotocol/sdk": "^1.25.2",
-    "@octokit/auth-app": "^8.1.0",
+    "@anthropic-ai/claude-code": "^2.1.7",
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@aws-sdk/client-dynamodb": "^3.990.0",
+    "@aws-sdk/s3-request-presigner": "^3.990.0",
+    "@aws-sdk/util-dynamodb": "^3.990.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@octokit/auth-app": "^8.2.0",
     "@octokit/request": "^10.0.3",
     "@octokit/rest": "^22.0.0",
-    "@react-router/express": "^7.11.0",
-    "@react-router/node": "^7.11.0",
-    "react-router": "^7.12.0",
+    "@react-router/express": "^7.13.0",
+    "@react-router/node": "^7.13.1",
+    "react-router": "^7.13.0",
     "@sendgrid/mail": "^8.1.4",
     "@supabase/supabase-js": "2.88.0",
-    "better-sqlite3": "^12.4.1",
+    "better-sqlite3": "^12.6.2",
     "chalk": "^5.6.2",
     "chokidar": "^4.0.3",
-    "cli-spinners": "^3.3.0",
+    "cli-spinners": "^3.4.0",
     "domhandler": "^5.0.3",
     "dotenv": "^17.2.3",
     "express": "^5.2.1",
     "fetch-retry": "^6.0.0",
     "get-port": "^7.1.0",
-    "htmlparser2": "^10.0.0",
+    "htmlparser2": "^10.1.0",
     "isbot": "^4",
     "jsdom": "^27.4.0",
     "json5": "^2.2.3",
     "jsonc-parser": "^3.2.1",
-    "kysely": "^0.28.5",
-    "lru-cache": "^11.2.4",
+    "kysely": "^0.28.11",
+    "lru-cache": "^11.2.5",
     "lucide-react": "^0.556.0",
+    "minimatch": "^10.2.3",
     "openai": "^6.16.0",
-    "p-queue": "^8.1.0",
+    "p-queue": "^9.1.0",
     "p-retry": "^7.1.1",
-    "pg": "^8.16.3",
+    "pg": "^8.19.0",
     "piscina": "^5.1.4",
     "pixelmatch": "^5.3.0",
-    "playwright": "^1.56.1",
+    "playwright": "1.58.0",
     "pluralize": "^8.0.0",
     "prompts": "^2.4.2",
     "react": "^19.2.3",
-    "react-diff-viewer-continued": "^4.0.6",
+    "react-diff-viewer-continued": "4.0.6",
     "react-dom": "^19.2.3",
+    "react-markdown": "^10.1.0",
     "react-resizable": "^3.0.5",
     "react-syntax-highlighter": "^15.6.1",
+    "remark-gfm": "^4.0.1",
+    "node-pty": "^1.0.0",
     "sharp": "^0.34.5",
-    "simple-git": "^3.28.0",
+    "ws": "^8.18.3",
+    "simple-git": "^3.32.2",
     "typescript": "^5.9.3",
     "uuid": "^11.1.0",
     "yargs": "^18.0.0",

package/packages/ai/index.js

@@ -26,19 +26,23 @@ export { default as describeCodeChange } from "./src/lib/describeCodeChange.js";
 export { default as validateTypeStructure } from "./src/lib/validateTypeStructure.js";
 export { default as validateDataStructure } from "./src/lib/validateDataStructure.js";
 export { default as isolateScopes } from "./src/lib/isolateScopes.js";
-export { default as analyzeScope } from "./src/lib/analyzeScope.js";
+export { default as analyzeScope, destroyWorkerPool, skipWorkerPool, } from "./src/lib/analyzeScope.js";
 export { default as logOrderedMap } from "./src/lib/logOrderedMap.js";
 export { default as splitOutsideParentheses, splitOutsideParenthesesAndArrays, joinParenthesesAndArrays, functionArguments, } from "./src/lib/splitOutsideParentheses.js";
 export { cleanKnownObjectFunctionsFromMapping } from "./src/lib/dataStructure/helpers/cleanKnownObjectFunctions.js";
 export { clearAttributesFromMapping, removeDuplicateFunctionCalls, } from "./src/lib/dataStructure/helpers/cleanNonObjectFunctions.js";
 export { default as convertDotNotation } from "./src/lib/dataStructure/helpers/convertDotNotation.js";
+export { default as convertTypeAnnotationsToValues } from "./src/lib/dataStructure/helpers/convertTypeAnnotationsToValues.js";
 export { default as cleanOutBoundary } from "./src/lib/cleanOutBoundary.js";
-export { fillInDirectSchemaGapsAndUnknowns } from "./src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns.js";
+export { fillInDirectSchemaGapsAndUnknowns, buildSchemaIndexes, } from "./src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns.js";
 export { default as deduplicateFunctionSchemas } from "./src/lib/dataStructure/helpers/deduplicateFunctionSchemas.js";
 export { default as getConditionalUsagesFromCode } from "./src/lib/getConditionalUsagesFromCode.js";
-export { getExternalFunctionCallInfo, getFunctionSignature, getReturnValue, getUsageEquivalencies, getSourceEquivalencies, getEquivalentSignatureVariables, getConditionalUsages, getConditionalEffects, getCompoundConditionals, getChildBoundaryGatingConditions, } from "./src/lib/worker/SerializableDataStructure.js";
+export { getExternalFunctionCallInfo, getFunctionSignature, getReturnValue, getUsageEquivalencies, getSourceEquivalencies, getEquivalentSignatureVariables, getConditionalUsages, getConditionalEffects, getCompoundConditionals, getChildBoundaryGatingConditions, getJsxRenderingUsages, } from "./src/lib/worker/SerializableDataStructure.js";
 export { parseJsonSafe } from "./src/lib/parsers/parseJsonSafe.js";
 export { default as completionCall } from "./src/lib/completionCall.js";
+// NOTE: E2E data tracking utilities (e2eDataTracking.ts) are NOT exported here
+// because they use Node.js 'crypto' module which breaks browser builds.
+// Import directly from "../../packages/ai/src/lib/e2eDataTracking.js" when needed in Node.js tests.
 // Wrapper detection
 export { default as detectWrapperRequirements } from "./src/lib/wrapperDetection/detectWrapperRequirements.js";
 export { KNOWN_LIBRARY_HOOKS } from "./src/lib/wrapperDetection/knownLibraryHooks.js";

package/packages/ai/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/ai/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AAC/F,OAAO,EAAE,OAAO,IAAI,kCAAkC,EAAE,MAAM,8CAA8C,CAAC;AAC7G,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAC3F,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AAC/F,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AACvF,OAAO,EACL,OAAO,IAAI,0BAA0B,EACrC,uBAAuB,GACxB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,8BAA8B,EAAE,MAAM,0CAA0C,CAAC;AACrG,OAAO,EAAE,OAAO,IAAI,iCAAiC,EAAE,MAAM,6CAA6C,CAAC;AAC3G,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AACrF,OAAO,EACL,OAAO,IAAI,yBAAyB,GAErC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,OAAO,IAAI,gCAAgC,GAG5C,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,oCAAoC,CAAC;AACzF,OAAO,EAAE,OAAO,IAAI,0CAA0C,EAAE,MAAM,sDAAsD,CAAC;AAC7H,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EACL,OAAO,IAAI,uBAAuB,EAClC,gCAAgC,EAChC,wBAAwB,EACxB,iBAAiB,GAClB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,oCAAoC,EAAE,MAAM,2DAA2D,CAAC;AACjH,OAAO,EACL,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AACnG,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,iCAAiC,EAAE,MAAM,6DAA6D,CAAC;AAChH,OAAO,EAAE,OAAO,IAAI,0BAA0B,EAAE,MAAM,4DAA4D,CAAC;AACnH,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAajG,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,EACpB,cAAc,EACd,qBAAqB,EACrB,sBAAsB,EACtB,+BAA+B,EAC/B,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,gCAAgC,GACjC,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAErE,oBAAoB;AACpB,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,sDAAsD,CAAC;AAC5G,OAAO,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAGnF,cAAc,qBAAqB,CAAC;AAEpC,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAE3C,2CAA2C;AAC3C,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,eAAe,EACf,kBAAkB,GACnB,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/ai/index.ts"],"names":[],"mappings":"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"}

package/packages/ai/src/lib/analyzeScope.js

@@ -34,6 +34,19 @@ import { isMainThread } from 'worker_threads';
 import fs from 'fs';
 // Worker pool for offloading analyzeScope to worker threads
 let workerPool = null;
+let workerPoolDestroyed = false;
+let workerPoolSkipped = false;
+/**
+ * Skip worker pool initialization for the current session.
+ *
+ * The worker thread creates its own ProjectAnalyzer (ts.Program), which takes
+ * 50-70s — far longer than the actual entity processing (<2s for typical batches).
+ * When the entity count is small, running analyzeScopeLocal on the main thread
+ * reuses the existing ProjectAnalyzer and avoids this overhead entirely.
+ */
+export function skipWorkerPool() {
+    workerPoolSkipped = true;
+}
 /**
  * Check if we're in Node.js main thread
  * Returns true for browser environments (where workers don't apply)
@@ -46,11 +59,44 @@ function getIsMainThread() {
     }
     return isMainThread;
 }
+/**
+ * Destroy the worker pool, freeing its ~2GB heap.
+ * Called after data structure preparation completes (the producing phase transition).
+ * The worker is not needed after this point — subsequent calls to ensureWorkerPool() will throw.
+ */
+export async function destroyWorkerPool() {
+    if (workerPool) {
+        const memBefore = process.memoryUsage();
+        console.log('CodeYam: Destroying worker pool...', {
+            rssBefore: `${Math.round(memBefore.rss / 1024 / 1024)}MB`,
+            heapBefore: `${Math.round(memBefore.heapUsed / 1024 / 1024)}MB`,
+        });
+        await workerPool.destroy();
+        workerPool = null;
+        // Force GC if available to reclaim worker memory faster
+        if (global.gc) {
+            global.gc();
+        }
+        const memAfter = process.memoryUsage();
+        console.log('CodeYam: Worker pool destroyed', {
+            rssAfter: `${Math.round(memAfter.rss / 1024 / 1024)}MB`,
+            heapAfter: `${Math.round(memAfter.heapUsed / 1024 / 1024)}MB`,
+            rssDelta: `${Math.round((memAfter.rss - memBefore.rss) / 1024 / 1024)}MB`,
+        });
+    }
+    workerPoolDestroyed = true;
+}
 /**
  * Lazy initialization of worker pool.
  * Called on first use to ensure environment variables are set.
  */
 function ensureWorkerPool() {
+    if (workerPoolDestroyed) {
+        throw new Error('CodeYam: Worker pool was destroyed (post-producing phase). ' +
+            'analyzeScope should not be called after data structure preparation completes.');
+    }
+    if (workerPoolSkipped)
+        return;
     if (workerPool !== null)
         return;
     // Only initialize worker pool in Node.js environment
@@ -62,9 +108,14 @@ function ensureWorkerPool() {
     }
     // Note: WORKER_PATH is null when __mocks__/analyzeScope.ts is active
     const { WORKER_PATH } = analyzeScopeWorkerPaths();
+    // Disable workers when tracing is enabled - we need access to ScopeDataStructure
+    // instance in the main thread to capture pre-serialization state
+    const tracingEnabled = process.env.CODEYAM_TRACE_TRANSFORMS === '1' ||
+        process.env.CODEYAM_TRACE_TRANSFORMS === 'true';
     if (process.env.USE_WORKER_THREADS &&
         WORKER_PATH &&
-        fs.existsSync(WORKER_PATH)) {
+        fs.existsSync(WORKER_PATH) &&
+        !tracingEnabled) {
         console.log('CodeYam: Using worker threads for analyzeScope', {
             WORKER_PATH,
         });
@@ -92,6 +143,7 @@ function ensureWorkerPool() {
             WORKER_PATH,
             workerExists: WORKER_PATH ? fs.existsSync(WORKER_PATH) : false,
             USE_WORKER_THREADS: process.env.USE_WORKER_THREADS,
+            tracingEnabled,
         });
         workerPool = null; // Explicitly set to indicate "no workers"
     }
@@ -123,6 +175,8 @@ export async function analyzeScopeLocal({ entity, fileAnalyzer, scope, scopeData
         const allDerivedVariables = {};
         // Collect child boundary gating conditions across all statements
         const allChildBoundaryGatingConditions = {};
+        // Collect JSX rendering usages (arrays via .map(), strings via interpolation)
+        const allJsxRenderingUsages = [];
         const astAnalysisResultWithStatements = statementScopes.map((statementScope) => {
             const astAnalysisResult = analyzeScopeWithAst(fileAnalyzer, statementScope);
             // Collect environment variables from AST analysis
@@ -136,12 +190,6 @@ export async function analyzeScopeLocal({ entity, fileAnalyzer, scope, scopeData
             }
             // Collect conditional effects from AST analysis
             if (astAnalysisResult.conditionalEffects?.length > 0) {
-                console.log(`[ConditionalEffects] analyzeScope collecting from statement "${statementScope.name}":`, astAnalysisResult.conditionalEffects.map((e) => ({
-                    setter: e.effect.setterName,
-                    value: e.effect.value,
-                    condition: e.condition?.path ||
-                        e.conditions?.map((c) => c.path).join(' && '),
-                })));
                 allConditionalEffects.push(...astAnalysisResult.conditionalEffects);
             }
             // Collect compound conditionals from AST analysis
@@ -163,6 +211,10 @@ export async function analyzeScopeLocal({ entity, fileAnalyzer, scope, scopeData
                     allChildBoundaryGatingConditions[childName].push(...usages);
                 }
             }
+            // Collect JSX rendering usages from AST analysis
+            if (astAnalysisResult.jsxRenderingUsages?.length) {
+                allJsxRenderingUsages.push(...astAnalysisResult.jsxRenderingUsages);
+            }
             return {
                 statementScope,
                 astAnalysisResult,
@@ -228,7 +280,7 @@ export async function analyzeScopeLocal({ entity, fileAnalyzer, scope, scopeData
                     }, null, 2));
                 }
                 for (const mapping of [structure, equivalentVariables]) {
-                    for (let [key, value] of Object.entries(mapping)) {
+                    for (let [key, rawValue] of Object.entries(mapping)) {
                         for (const [childScopeId, childScope] of sortedEntries) {
                             const scopeText = fileAnalyzer.sourceFile.text.slice(childScope.start, childScope.end);
                             const replaceChildScopeId = (text) => {
@@ -243,18 +295,35 @@ export async function analyzeScopeLocal({ entity, fileAnalyzer, scope, scopeData
                                 }
                                 return text;
                             };
-                            if (value.includes(scopeText)) {
-                                // DEBUG: Log when replacement happens
-                                if (key.includes('Fetcher') || key.includes('fetcher')) {
-                                    console.log('CodeYam DEBUG value replacement:', JSON.stringify({
-                                        key,
-                                        oldValue: value,
-                                        childScopeId,
-                                        scopeTextPreview: scopeText.slice(0, 50),
-                                    }));
+                            // Handle both string and string[] values (for OR expressions)
+                            const processValue = (value) => {
+                                if (value.includes(scopeText)) {
+                                    // DEBUG: Log when replacement happens
+                                    if (key.includes('Fetcher') || key.includes('fetcher')) {
+                                        console.log('CodeYam DEBUG value replacement:', JSON.stringify({
+                                            key,
+                                            oldValue: value,
+                                            childScopeId,
+                                            scopeTextPreview: scopeText.slice(0, 50),
+                                        }));
+                                    }
+                                    return replaceChildScopeId(value);
+                                }
+                                return value;
+                            };
+                            if (Array.isArray(rawValue)) {
+                                const newValues = rawValue.map(processValue);
+                                mapping[key] =
+                                    newValues;
+                                rawValue = newValues;
+                            }
+                            else if (typeof rawValue === 'string') {
+                                const newValue = processValue(rawValue);
+                                if (newValue !== rawValue) {
+                                    mapping[key] =
+                                        newValue;
+                                    rawValue = newValue;
                                 }
-                                value = replaceChildScopeId(value);
-                                mapping[key] = value;
                             }
                             if (key.includes(scopeText)) {
                                 const oldKey = key;
@@ -396,12 +465,8 @@ export async function analyzeScopeLocal({ entity, fileAnalyzer, scope, scopeData
         }
         // Add conditional effects from this scope's analysis
         if (allConditionalEffects.length > 0) {
-            console.log(`[ConditionalEffects] analyzeScope adding ${allConditionalEffects.length} effects to scopeDataStructure for scope "${scope.name}"`);
             scopeDataStructure.addConditionalEffects(allConditionalEffects);
         }
-        else {
-            console.log(`[ConditionalEffects] analyzeScope: no conditional effects found for scope "${scope.name}"`);
-        }
         // Add compound conditionals from this scope's analysis
         if (allCompoundConditionals.length > 0) {
             scopeDataStructure.addCompoundConditionals(allCompoundConditionals);
@@ -441,10 +506,9 @@ export async function analyzeScopeLocal({ entity, fileAnalyzer, scope, scopeData
         if (Object.keys(allChildBoundaryGatingConditions).length > 0) {
             scopeDataStructure.addChildBoundaryGatingConditions(allChildBoundaryGatingConditions);
         }
-        // Log child scopes that will be processed
-        const childScopeNames = Object.keys(scope.childScopes);
-        if (childScopeNames.length > 0) {
-            console.log(`[ConditionalEffects] analyzeScope will process ${childScopeNames.length} child scopes:`, childScopeNames);
+        // Add JSX rendering usages from this scope's analysis
+        if (allJsxRenderingUsages.length > 0) {
+            scopeDataStructure.addJsxRenderingUsages(allJsxRenderingUsages);
         }
         await Promise.all(Object.values(scope.childScopes).map(async (childScope) => {
             // This is awkward but need to identify class scopes
@@ -510,9 +574,6 @@ export default async function analyzeScope(args) {
         console.log(`CodeYam: Dispatching analyzeScope to worker for ${entity.name}`);
         try {
             const result = await workerPool.run(workerInput);
-            // Log the conditional effects from the worker result
-            const workerConditionalEffects = result.dataStructure?.conditionalEffects || [];
-            console.log(`[ConditionalEffects] Worker returned ${workerConditionalEffects.length} conditional effects for ${entity.name}:`, workerConditionalEffects.map((e) => `${e.effect?.setterName}(${e.effect?.value})`));
             // Store the serializable data structure in the scope
             scope.dataStructure = result.dataStructure;
             return;