scai 0.1.157 → 0.1.158

package/dist/pipeline/modules/semanticAnalysisModule.js

@@ -5,16 +5,28 @@ import { generate } from "../../lib/generate.js";
 const MAX_CODE_CHARS = 6000; // conservative prompt-safe limit
 export const semanticAnalysisModule = {
     name: "semanticAnalysis",
-    description: "Performs semantic analysis for each file provided by the plan steps, storing file-level and combined insights.",
+    description: "Performs semantic analysis for a single target file defined by the current execution step.",
     groups: ["analysis"],
     run: async (input) => {
         var _a, _b;
         const context = input.context;
         if (!context)
             throw new Error("[semanticAnalysisStep] No context provided");
+        const step = context.currentStep;
+        if (!step || step.action !== "semanticAnalysis") {
+            const notes = "[semanticAnalysisStep] Invoked without semanticAnalysis step";
+            logInputOutput("semanticAnalysisStep", "output", { notes });
+            return { query: input.query, data: { notes }, context };
+        }
+        if (!step.targetFile) {
+            const notes = "[semanticAnalysisStep] semanticAnalysis step missing targetFile";
+            logInputOutput("semanticAnalysisStep", "output", { notes });
+            return { query: input.query, data: { notes }, context };
+        }
         const workingFiles = context.workingFiles ?? [];
-        if (!workingFiles.length) {
-            const notes = "[semanticAnalysisStep] No working files loaded; skipping semantic analysis";
+        const file = workingFiles.find(f => f.path === step.targetFile);
+        if (!file) {
+            const notes = `[semanticAnalysisStep] targetFile not found: ${step.targetFile}`;
             logInputOutput("semanticAnalysisStep", "output", { notes });
             return { query: input.query, data: { notes }, context };
         }
@@ -22,56 +34,37 @@ export const semanticAnalysisModule = {
         (_a = context.analysis).fileAnalysis || (_a.fileAnalysis = {});
         (_b = context.analysis).combinedAnalysis || (_b.combinedAnalysis = {});
         const intentCategory = context.analysis.intent?.intentCategory ?? "other";
-        // Determine which files to analyze based on plan steps
-        const planSteps = context.analysis.planSuggestion?.plan?.steps ?? [];
-        const filesToAnalyze = planSteps
-            .filter(step => step.action === "semanticAnalysis" && step.targetFile)
-            .map(step => step.targetFile)
-            .map(path => workingFiles.find(f => f.path === path))
-            .filter(Boolean);
-        // ----------------------------
-        // 1️⃣ Per-file semantic analysis
-        // ----------------------------
-        for (const file of filesToAnalyze) {
-            const filePath = file.path;
-            const prevAnalysis = context.analysis.fileAnalysis[filePath];
-            // Use evidence relevance if available
-            const isRelevant = prevAnalysis?.action?.isRelevant ?? false;
-            if (!isRelevant)
-                continue; // skip irrelevant files
-            const shouldModify = prevAnalysis?.action?.shouldModify ?? determineShouldModify(intentCategory, isRelevant);
-            // Analyze the file (enriching previous evidence)
-            const semanticAnalysis = await analyzeFile(file, input.query, context, isRelevant, shouldModify);
-            context.analysis.fileAnalysis[filePath] = {
-                ...prevAnalysis, // keep evidence and prior info
-                ...semanticAnalysis, // add semantic insights
-                action: { isRelevant, shouldModify },
-            };
-            logInputOutput("semanticAnalysisStep - per-file", "output", {
-                file: filePath,
-                analysis: context.analysis.fileAnalysis[filePath],
-            });
-        }
-        // ----------------------------
-        // 2️⃣ Cross-file combined analysis (optional)
-        // Only consider relevant files
-        // ----------------------------
+        const filePath = file.path;
+        const prevAnalysis = context.analysis.fileAnalysis[filePath];
+        // Default: allow semantic analysis to determine relevance
+        const isRelevant = prevAnalysis?.action?.isRelevant ?? true;
+        const shouldModify = prevAnalysis?.action?.shouldModify ??
+            determineShouldModify(intentCategory, isRelevant);
+        const semanticAnalysis = await analyzeFile(file, input.query, context, isRelevant, shouldModify);
+        context.analysis.fileAnalysis[filePath] = {
+            ...prevAnalysis,
+            ...semanticAnalysis,
+            action: { isRelevant, shouldModify },
+        };
+        logInputOutput("semanticAnalysisStep - per-file", "output", {
+            file: filePath,
+            analysis: context.analysis.fileAnalysis[filePath],
+        });
+        // -------------------------------------------------
+        // ⚠️ Transitional: opportunistic combined analysis
+        // -------------------------------------------------
         const relevantFiles = Object.entries(context.analysis.fileAnalysis)
             .filter(([_, analysis]) => analysis.action?.isRelevant)
             .map(([path]) => path);
-        let combinedAnalysis = {
-            sharedPatterns: [],
-            architectureSummary: "[skipped]",
-            hotspots: [],
-        };
         if (relevantFiles.length > 2) {
-            const filteredAnalysis = {};
-            for (const path of relevantFiles)
-                filteredAnalysis[path] = context.analysis.fileAnalysis[path];
-            combinedAnalysis = await analyzeCombined(filteredAnalysis, input.query);
+            const filtered = {};
+            for (const path of relevantFiles) {
+                filtered[path] = context.analysis.fileAnalysis[path];
+            }
+            const combinedAnalysis = await analyzeCombined(filtered, input.query);
+            context.analysis.combinedAnalysis = combinedAnalysis;
             logInputOutput("semanticAnalysisStep - combined", "output", combinedAnalysis);
         }
-        context.analysis.combinedAnalysis = combinedAnalysis;
         return {
             query: input.query,
             data: { notes: "Semantic analysis completed" },
@@ -104,9 +97,9 @@ ${contextSnippet}
 File path: ${file.path}
 
 Task:
-- Analyze this file thoroughly based on the description in the plan.
-- Identify key functions, classes, data structures, and logical roles in the system.
-- Provide semantic insights that would help any future transformations or reasoning steps.
+- Analyze this file thoroughly based on its role in the system.
+- Identify key functions, classes, data structures, and responsibilities.
+- Provide semantic insights useful for future reasoning or transformations.
 
 Code excerpt:
 ${slicedCode ?? "[no code]"}
@@ -141,15 +134,18 @@ Return STRICT JSON:
                 data = {};
             }
         }
-        const intent = data.intent === "relevant" || data.intent === "irrelevant" ? data.intent : "irrelevant";
+        const intent = data.intent === "relevant" || data.intent === "irrelevant"
+            ? data.intent
+            : "irrelevant";
         return {
             intent,
             relevance: typeof data.relevance === "string" && data.relevance.trim()
                 ? data.relevance
                 : intent === "relevant"
                     ? "This file appears relevant to the query."
-                    : "This file does not appear relevant to answering the query.",
-            role: intent === "relevant" && ["primary", "supporting", "contextual"].includes(data.role)
+                    : "This file does not appear relevant to the query.",
+            role: intent === "relevant" &&
+                ["primary", "supporting", "contextual"].includes(data.role)
                 ? data.role
                 : undefined,
             action: { shouldModify },
@@ -157,8 +153,12 @@ Return STRICT JSON:
                 ? {
                     summary: String(data.proposedChanges.summary ?? ""),
                     scope: data.proposedChanges.scope ?? "none",
-                    targets: Array.isArray(data.proposedChanges.targets) ? data.proposedChanges.targets : undefined,
-                    rationale: typeof data.proposedChanges.rationale === "string" ? data.proposedChanges.rationale : undefined,
+                    targets: Array.isArray(data.proposedChanges.targets)
+                        ? data.proposedChanges.targets
+                        : undefined,
+                    rationale: typeof data.proposedChanges.rationale === "string"
+                        ? data.proposedChanges.rationale
+                        : undefined,
                 }
                 : { summary: "No changes required for this file.", scope: "none" },
             risks: Array.isArray(data.risks) ? data.risks : [],
@@ -214,7 +214,9 @@ Return STRICT JSON:
     try {
         const ai = await generate({ query: "cross-file analysis", content: prompt });
         const cleaned = await cleanupModule.run({ query, content: ai.data });
-        const data = typeof cleaned.data === "object" && cleaned.data ? cleaned.data : JSON.parse(String(cleaned.content ?? "{}"));
+        const data = typeof cleaned.data === "object" && cleaned.data
+            ? cleaned.data
+            : JSON.parse(String(cleaned.content ?? "{}"));
         return {
             sharedPatterns: data.sharedPatterns ?? [],
             architectureSummary: data.architectureSummary ?? "[unparsed]",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.157",
+  "version": "0.1.158",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"