scai 0.1.168 → 0.1.170

package/dist/agents/MainAgent.js

@@ -19,6 +19,7 @@ import { selectRelevantSourcesStep } from "./selectRelevantSourcesStep.js";
 import { iterationFileSelector } from "./iterationFileSelector.js";
 import { finalAnswerModule } from "../pipeline/modules/finalAnswerModule.js";
 import { reasonNextStep } from "./reasonNextStep.js";
+import { structuralPreloadStep } from "./structuralPreloadStep.js";
 import chalk from "chalk";
 /* ───────────────────────── registry ───────────────────────── */
 const MODULE_REGISTRY = Object.fromEntries(Object.entries(builtInModules).map(([name, mod]) => [name, mod]));
@@ -95,6 +96,10 @@ export class MainAgent {
         let ready = false;
         while (this.runCount < this.maxRuns) {
             // ---------------- EVIDENCE PIPELINE ----------------
+            // -------- STRUCTURAL PRELOAD --------
+            const t0 = this.startTimer();
+            await structuralPreloadStep.run({ query: this.query, context: this.context });
+            this.logLine("ANALYSIS", "structuralPreload", t0());
             const t1 = this.startTimer();
             await evidenceVerifierStep.run({ query: this.query, context: this.context });
             this.logLine("ANALYSIS", "collectAnalysisEvidence", t1());

package/dist/agents/evidenceVerifierStep.js

@@ -7,6 +7,7 @@ import { logInputOutput } from "../utils/promptLogHelper.js";
  * - Filters stopwords and short tokens.
  * - Deduplicates symbol evidence per file.
  * - Removes low-signal keyword clustering.
+ * - Strictly leverages structural data (functions, classes, imports/exports) for additional evidence.
  */
 export const evidenceVerifierStep = {
     name: "evidenceVerifier",
@@ -111,7 +112,7 @@ export const evidenceVerifierStep = {
             const evidenceItems = [];
             const matchedLines = [];
             const addedSymbols = new Set();
-            // Sentence matches
+            // -------- Sentence matches --------
             lines.forEach((line, idx) => {
                 sentenceTargets.forEach(target => {
                     if (line.includes(target)) {
@@ -129,7 +130,7 @@ export const evidenceVerifierStep = {
                     }
                 });
             });
-            // Symbol matches (deduplicated per symbol)
+            // -------- Symbol matches --------
             uniqueSymbolTargets.forEach(sym => {
                 for (let idx = 0; idx < lines.length; idx++) {
                     const line = lines[idx];
@@ -150,11 +151,11 @@ export const evidenceVerifierStep = {
                             });
                             matchedLines.push(line);
                         }
-                        break; // stop after first meaningful match
+                        break;
                     }
                 }
             });
-            // Filename-level evidence
+            // -------- Filename-level evidence --------
             const fullFileName = path.split("/").pop() ?? "";
             const baseFileName = fullFileName.replace(/\.(ts|js|tsx|md)$/, "");
             if (filenameTargets.includes(fullFileName) ||
@@ -167,23 +168,82 @@ export const evidenceVerifierStep = {
                     confidence: 1,
                 });
             }
-            // ----------------- Compute file-level confidence -----------------
+            // -------- Structural evidence (strict) --------
+            const struct = context.analysis.fileAnalysis[path]?.structural;
+            const structuralEvidence = [];
+            if (struct) {
+                const queryTokens = query
+                    .toLowerCase()
+                    .match(/\b\w{3,}\b/g) ?? [];
+                const querySet = new Set(queryTokens);
+                (struct.functions ?? []).forEach(fn => {
+                    if (fn.name && querySet.has(fn.name.toLowerCase())) {
+                        const ev = {
+                            claim: `Function name matches query: "${fn.name}"`,
+                            type: "structural",
+                            excerpt: fn.name,
+                            span: { startLine: fn.start ?? 0, endLine: fn.end ?? 0 },
+                            confidence: 0.85,
+                        };
+                        evidenceItems.push(ev);
+                        structuralEvidence.push(ev);
+                    }
+                });
+                (struct.classes ?? []).forEach(cls => {
+                    if (cls.name && querySet.has(cls.name.toLowerCase())) {
+                        const ev = {
+                            claim: `Class name matches query: "${cls.name}"`,
+                            type: "structural",
+                            excerpt: cls.name,
+                            span: { startLine: cls.start ?? 0, endLine: cls.end ?? 0 },
+                            confidence: 0.85,
+                        };
+                        evidenceItems.push(ev);
+                        structuralEvidence.push(ev);
+                    }
+                });
+                [...(struct.imports ?? []), ...(struct.exports ?? [])].forEach(sym => {
+                    if (sym && querySet.has(sym.toLowerCase())) {
+                        const ev = {
+                            claim: `Import/Export matches query: "${sym}"`,
+                            type: "structural",
+                            excerpt: sym,
+                            span: { startLine: 0, endLine: 0 },
+                            confidence: 0.85,
+                        };
+                        evidenceItems.push(ev);
+                        structuralEvidence.push(ev);
+                    }
+                });
+                // -------- Log structural evidence per file --------
+                if (structuralEvidence.length > 0) {
+                    logInputOutput("evidenceVerifier", "output", {
+                        file: path,
+                        count: structuralEvidence.length,
+                        examples: structuralEvidence.slice(0, 5).map(ev => ({
+                            claim: ev.claim,
+                            excerpt: ev.excerpt,
+                            confidence: ev.confidence,
+                        })),
+                    });
+                }
+            }
+            // -------- Compute file-level confidence --------
             let fileScore = 0;
             for (const ev of evidenceItems) {
                 if (ev.type === "sentence")
                     fileScore += 1.0;
                 else if (ev.type === "filename")
                     fileScore += 1.0;
-                else if (ev.type === "symbol")
+                else if (ev.type === "symbol" || ev.type === "structural")
                     fileScore += ev.confidence ?? 0.8;
             }
-            // Normalize to 0–1 range (soft cap)
             const fileConfidence = fileScore === 0
                 ? 0
-                : Math.min(1, fileScore / 3); // 3 strong signals = max confidence
+                : Math.min(1, fileScore / 3);
             const isFocusFile = context.analysis.focus?.selectedFiles?.includes(path) ?? false;
             const hasEvidence = evidenceItems.length > 0;
-            // ----------------- Merge into fileAnalysis -----------------
+            // -------- Merge into fileAnalysis --------
             if (isFocusFile || hasEvidence) {
                 const confidenceLabel = fileConfidence.toFixed(2);
                 context.analysis.fileAnalysis[path] = {
@@ -229,7 +289,6 @@ export const evidenceVerifierStep = {
             query,
             data: { fileAnalysis: context.analysis.fileAnalysis },
         };
-        // Build compact log summary
         const logSummary = Object.entries(context.analysis.fileAnalysis).map(([path, analysis]) => {
             const evidenceCount = analysis.evidence?.length ?? 0;
             const confidenceMatch = analysis.relevanceExplanation?.match(/\[confidence:(\d+\.\d+)\]/);

package/dist/agents/structuralPreloadStep.js

@@ -0,0 +1,61 @@
+// File: src/modules/structuralPreloadStep.ts
+import { buildInDepthContext } from "../utils/buildContextualPrompt.js";
+import { logInputOutput } from "../utils/promptLogHelper.js";
+/**
+ * Structural preload:
+ * - Calls buildInDepthContext for candidate files.
+ * - Extracts structural facts only.
+ * - Populates analysis.fileAnalysis[path].structural.
+ * - Does NOT reason or assign relevance.
+ */
+export const structuralPreloadStep = {
+    name: "structuralPreload",
+    description: "Preloads structural KG and code metadata into fileAnalysis without performing reasoning.",
+    groups: ["analysis"],
+    run: async (input) => {
+        const query = input.query ?? "";
+        const context = input.context;
+        if (!context?.analysis) {
+            throw new Error("[structuralPreload] context.analysis is required.");
+        }
+        // ---- Ensure fileAnalysis exists (type-safe) ----
+        if (!context.analysis.fileAnalysis) {
+            context.analysis.fileAnalysis = {};
+        }
+        const fileAnalysis = context.analysis.fileAnalysis;
+        // ---- Candidate files ----
+        const candidatePaths = [
+            ...(context.initContext?.relatedFiles ?? []),
+        ];
+        const uniquePaths = Array.from(new Set(candidatePaths));
+        if (!uniquePaths.length) {
+            console.warn("[structuralPreload] No candidate files to preload.");
+            return { query, data: {} };
+        }
+        // ---- Only preload missing structural data ----
+        const pathsNeedingStructure = uniquePaths.filter((p) => !fileAnalysis[p]?.structural);
+        if (!pathsNeedingStructure.length)
+            return { query, data: {} };
+        // ---- Get structural data (path → structural object) ----
+        const structuralMap = await buildInDepthContext({
+            filenames: pathsNeedingStructure,
+            relatedFiles: context.initContext?.relatedFiles ?? [],
+            query,
+        });
+        // ---- Merge into fileAnalysis ----
+        for (const [path, structural] of Object.entries(structuralMap)) {
+            fileAnalysis[path] ?? (fileAnalysis[path] = { semanticAnalyzed: false });
+            fileAnalysis[path].structural = structural;
+        }
+        // ---- Minimal structured log ----
+        const logSummary = Object.entries(fileAnalysis).map(([path, analysis]) => ({
+            file: path,
+            hasStructural: !!analysis.structural,
+            functions: analysis.structural?.functions?.length ?? 0,
+            classes: analysis.structural?.classes?.length ?? 0,
+            imports: analysis.structural?.imports?.length ?? 0,
+        }));
+        logInputOutput("structuralPreload", "output", logSummary);
+        return { query, data: {} };
+    },
+};

package/dist/utils/buildContextualPrompt.js

@@ -218,44 +218,23 @@ function extractFileReferences(query) {
     return [...new Set(matches)];
 }
 /* ======================================================
-   IN-DEPTH CONTEXT
+   IN-DEPTH CONTEXT (Structural-Only)
    ====================================================== */
 export async function buildInDepthContext({ filenames, kgDepth = DEFAULT_KG_DEPTH, relatedFiles, query, }) {
     const db = getDbForRepo();
     const safeFilenames = Array.isArray(filenames) ? filenames : [];
-    const safeRelated = Array.isArray(relatedFiles) ? relatedFiles : [];
-    const initCtx = {
-        userQuery: query?.trim() || "",
-        repoTree: safeGenerateRepoTree(3),
-        relatedFiles: safeRelated,
-        folderCapsules: loadRelevantFolderCapsules(normalizeToFolders(safeRelated)),
-    };
-    const workingFiles = [];
-    const out = {
-        initContext: initCtx,
-        workingFiles,
-        task: {
-            id: 0,
-            projectId: 0,
-            status: "active",
-            initialQuery: query?.trim() ?? "",
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            taskSteps: [],
-        },
-    };
-    /* -------- Working files (deep phase only) -------- */
+    const result = {};
     for (const p of safeFilenames) {
         const fileId = fileRowIdForPath(db, p);
-        const fileObj = { path: p };
+        const structural = {};
         if (typeof fileId === "number") {
-            fileObj.functions = loadFunctions(db, fileId, MAX_FUNCTIONS);
-            fileObj.classes = loadClasses(db, fileId, 200);
+            structural.functions = loadFunctions(db, fileId, MAX_FUNCTIONS);
+            structural.classes = loadClasses(db, fileId, 200);
         }
         const neighbors = loadKgNeighbors(db, p, MAX_KG_NEIGHBORS);
-        fileObj.kgTags = loadKgTags(db, p, MAX_KG_NEIGHBORS);
+        structural.kgTags = loadKgTags(db, p, MAX_KG_NEIGHBORS);
         if (neighbors.length) {
-            fileObj.kgNeighborhood = neighbors.map((e) => `${e.relation}:${e.target}`);
+            structural.kgNeighborhood = neighbors.map((e) => `${e.relation}:${e.target}`);
             const imports = neighbors
                 .filter((e) => e.relation === "imports")
                 .map((e) => e.target);
@@ -263,12 +242,12 @@ export async function buildInDepthContext({ filenames, kgDepth = DEFAULT_KG_DEPT
                 .filter((e) => e.relation === "exports")
                 .map((e) => e.target);
             if (imports.length)
-                fileObj.imports = imports.slice(0, 200);
+                structural.imports = imports.slice(0, 200);
             if (exports.length)
-                fileObj.exports = exports.slice(0, 200);
+                structural.exports = exports.slice(0, 200);
         }
-        fileObj.focusedTree = safeGenerateFocusedTree(p, 3);
-        workingFiles.push(fileObj);
+        structural.focusedTree = safeGenerateFocusedTree(p, 3);
+        result[p] = structural;
     }
-    return out;
+    return result;
 }

package/package.json

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