scai 0.1.174 → 0.1.176

package/dist/agents/MainAgent.js

@@ -28,6 +28,8 @@ import { structuralPreloadStep } from "./structuralPreloadStep.js";
 import { extractFileReferences } from "../utils/extractFileReferences.js";
 import { PREFILTER_STOP_WORDS } from "../fileRules/stopWords.js";
 import { MAX_WELL_KNOWN_REPO_FILES, WELL_KNOWN_REPO_FILE_BASENAMES } from "../fileRules/wellKnownRepoFiles.js";
+import { isPathIgnoredByFolderGlobs } from "../fileRules/ignoredPaths.js";
+import { canExecutePhase, canExecuteRoute, canExecuteScope } from "./guardPolicy.js";
 import chalk from "chalk";
 import path from "path";
 import fs from "fs";
@@ -172,12 +174,12 @@ export class MainAgent {
                 break;
             }
             // ---------------- INFORMATION ACQUISITION ----------------
-            const canRouteSearchExpansion = this.canExecuteRoute("search-expand");
+            const canRouteSearchExpansion = canExecuteRoute(this.context, "search-expand");
             if (!canRouteSearchExpansion) {
                 this.logLine("PLAN", "infoPlanGen", undefined, "skipped (routing disallows search expansion)", { highlight: false });
             }
-            else if (this.canExecutePhase("planning") &&
-                this.canExecuteScope("planning")) {
+            else if (canExecutePhase(this.context, "planning") &&
+                canExecuteScope(this.context, "planning")) {
                 const t = this.startTimer();
                 await infoPlanGenStep.run(this.context);
                 const infoPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
@@ -208,7 +210,7 @@ export class MainAgent {
      */
     async runResearch() {
         var _a, _b;
-        if (!this.canExecuteRoute("research")) {
+        if (!canExecuteRoute(this.context, "research")) {
             this.logLine("RESEARCH", "taskStepSeed", undefined, "skipped (route disallows research)");
             return;
         }
@@ -298,7 +300,7 @@ export class MainAgent {
         var _a, _b;
         if (!this.context.task)
             return;
-        if (!this.canExecutePhase("planning") || !this.canExecuteScope("planning"))
+        if (!canExecutePhase(this.context, "planning") || !canExecuteScope(this.context, "planning"))
             return;
         (_a = this.context).analysis || (_a.analysis = {});
         (_b = this.context.task).taskSteps || (_b.taskSteps = []);
@@ -347,6 +349,7 @@ export class MainAgent {
             .filter(filePath => !!filePath && !filePath.startsWith("__research__/") && fs.existsSync(filePath))
             .sort((a, b) => rankPath(a) - rankPath(b))
             .slice(0, 16);
+        this.ensureWorkingFilesLoaded(plannedPaths, "Planned for execution");
         let seededCount = 0;
         const seeded = [];
         for (const filePath of plannedPaths) {
@@ -409,6 +412,15 @@ export class MainAgent {
         const routing = this.context.analysis.routingDecision;
         if (!routing)
             return;
+        const intentCategory = (this.context.analysis.intent?.intentCategory ?? "").toLowerCase();
+        const isEditLikeIntent = intentCategory === "codingtask" ||
+            intentCategory === "refactortask" ||
+            intentCategory === "request" ||
+            intentCategory === "docsandcomments";
+        const canWrite = this.context.executionControl?.constraints?.allowFileWrites ?? false;
+        if (!isEditLikeIntent || !canWrite) {
+            return;
+        }
         const selectedFiles = this.context.analysis.focus?.selectedFiles ?? [];
         if (selectedFiles.length === 0)
             return;
@@ -468,6 +480,9 @@ export class MainAgent {
             // Step-level iterations
             // ---------------------------
             const stepAction = await this.runStepIterations(taskStep);
+            if (stepAction === "expand-scope") {
+                this.applyScopeExpansionRouteHint();
+            }
             this.finishTaskStep(taskStep, stepCount, stepAction);
         }
         this.logLine("TASK", "Max task step limit reached — stopping work loop", undefined, undefined, { highlight: false });
@@ -507,6 +522,8 @@ export class MainAgent {
                 return "request-feedback";
             if (nextAction === "redo-step")
                 continue;
+            if (nextAction === "expand-scope")
+                return "expand-scope";
         }
         return "continue";
     }
@@ -522,7 +539,7 @@ export class MainAgent {
             await this.executeResearchTaskStep(taskStep);
             return;
         }
-        if (this.canExecutePhase("analysis") && this.canExecuteScope("analysis")) {
+        if (canExecutePhase(this.context, "analysis") && canExecuteScope(this.context, "analysis")) {
             const tAnalysis = this.startTimer();
             await analysisPlanGenStep.run(this.context);
             this.logLine("PLAN", "analysisPlanGen", tAnalysis(), undefined, { highlight: false });
@@ -535,7 +552,9 @@ export class MainAgent {
             if (this.context.analysis)
                 this.context.analysis.planSuggestion = undefined;
         }
-        if (this.canExecutePhase("transform") && this.canExecuteScope("transform")) {
+        if (canExecutePhase(this.context, "transform") &&
+            canExecuteScope(this.context, "transform") &&
+            canExecuteRoute(this.context, "transform")) {
             const tTransform = this.startTimer();
             await transformPlanGenStep.run(this.context);
             this.logLine("PLAN", "transformPlanGen", tTransform(), undefined, { highlight: false });
@@ -548,7 +567,7 @@ export class MainAgent {
             }
             if (this.context.analysis)
                 this.context.analysis.planSuggestion = undefined;
-            if (this.canExecutePhase("write") && this.canExecuteScope("write")) {
+            if (canExecutePhase(this.context, "write") && canExecuteScope(this.context, "write")) {
                 const tWrite = this.startTimer();
                 await writeFileStep.run({ query: this.query, context: this.context });
                 this.logLine("WRITE", "writeFileStep", tWrite());
@@ -1155,6 +1174,8 @@ export class MainAgent {
         const existsOrResearch = (filePath) => {
             if (filePath.startsWith("__research__/"))
                 return true;
+            if (isPathIgnoredByFolderGlobs(filePath))
+                return false;
             return fs.existsSync(filePath);
         };
         let removedRelated = 0;
@@ -1208,7 +1229,7 @@ export class MainAgent {
      */
     getTaskStepBudget() {
         const scope = this.context.analysis?.scopeType ?? "repo-wide";
-        if (this.canExecuteRoute("research"))
+        if (canExecuteRoute(this.context, "research"))
             return 10;
         if (scope === "multi-file")
             return 7;
@@ -1221,7 +1242,7 @@ export class MainAgent {
      * Example: require at least two analyzed files plus one understanding signal.
      */
     isResearchGateSatisfied() {
-        if (!this.canExecuteRoute("research"))
+        if (!canExecuteRoute(this.context, "research"))
             return true;
         const scope = this.context.analysis?.scopeType ?? "repo-wide";
         const researchPlanCount = this.context.task?.taskSteps?.filter(s => typeof s.action === "string" && s.action.startsWith("research-")).length ?? 0;
@@ -1292,28 +1313,45 @@ export class MainAgent {
         this.context.task.status = status;
         this.persistTaskDataForRun();
     }
+    applyScopeExpansionRouteHint() {
+        var _a;
+        (_a = this.context).analysis || (_a.analysis = {});
+        const route = this.context.analysis.routingDecision;
+        if (!route)
+            return;
+        route.decision = "needs-info";
+        route.allowSearch = true;
+        route.scopeLocked = false;
+        route.rationale = `${route.rationale}; stepReasoning=expand-scope`;
+        this.logLine("TASK", "Route updated from step reasoning", undefined, "expand-scope requested; re-enabled search expansion");
+    }
     startTaskStep(taskStep, stepCount) {
+        this.ensureWorkingFilesLoaded([taskStep.filePath], "Current task step");
+        const db = getDbForRepo();
+        this.ensureTaskIdentityForPersistence(db);
         this.context.task.currentStep = taskStep;
         taskStep.taskId = this.taskId;
         taskStep.stepIndex = stepCount;
         taskStep.status = "pending";
-        persistTaskStepInsert(taskStep, getDbForRepo());
+        persistTaskStepInsert(taskStep, db);
         const displayPath = this.formatTaskStepDisplayPath(taskStep.filePath);
         this.logLine("NEW STEP", `Processing taskStep ${stepCount}`, undefined, displayPath, { highlight: true });
         taskStep.startTime = Date.now();
-        persistTaskStepStart(taskStep, getDbForRepo());
+        persistTaskStepStart(taskStep, db);
     }
     finishTaskStep(taskStep, stepCount, stepAction) {
+        const db = getDbForRepo();
+        this.ensureTaskIdentityForPersistence(db);
         const displayPath = this.formatTaskStepDisplayPath(taskStep.filePath);
         taskStep.endTime = Date.now();
         if (stepAction === "complete") {
             taskStep.status = "completed";
-            persistTaskStepCompletion(taskStep, getDbForRepo());
+            persistTaskStepCompletion(taskStep, db);
             this.logLine("STEP-DONE", `Completed taskStep ${stepCount}`, undefined, displayPath, { highlight: false });
             return;
         }
         taskStep.status = "pending";
-        persistTaskStepCompletion(taskStep, getDbForRepo());
+        persistTaskStepCompletion(taskStep, db);
         this.logLine("STEP", `Pending taskStep ${stepCount}`, undefined, displayPath);
     }
     /**
@@ -1325,69 +1363,6 @@ export class MainAgent {
             ? filePath.replace("__research__/", "research/")
             : filePath;
     }
-    /* ───────────── execution gates ───────────── */
-    /**
-     * Gate model:
-     * 1) Phase + scope gates decide coarse permissions (what broad work is allowed).
-     * 2) Route gate decides finer sub-decisions within those allowed areas (what to do next).
-     */
-    /**
-     * Gate 1: Is this kind of work allowed at all?
-     * Plain meaning: checks capability rules (e.g. read-only vs file-writing).
-     * Example: for docs-only mode, analysis/planning are blocked, and writes are limited.
-     */
-    canExecutePhase(phase) {
-        const constraints = this.context.executionControl?.constraints;
-        const docsOnly = constraints?.docsOnly ?? false;
-        let allowed = false;
-        switch (phase) {
-            case "analysis":
-            case "planning":
-                allowed = !docsOnly;
-                break;
-            case "transform":
-            case "write":
-                allowed = constraints?.allowFileWrites ?? false;
-                break;
-        }
-        return allowed;
-    }
-    /* ───────────── scope gates ───────────── */
-    /**
-     * Gate 2: Is this work allowed for the current scope size?
-     * Plain meaning: checks scope rules (none/single/multi/repo-wide).
-     * Example: if scope is "analysis", only analysis/planning run and transform/write are blocked.
-     */
-    canExecuteScope(phase) {
-        const scope = this.context.analysis?.scopeType ?? "repo-wide";
-        let allowed = false;
-        switch (scope) {
-            case "none":
-                allowed = phase === "analysis" || phase === "planning";
-                break;
-            default:
-                allowed = true;
-        }
-        return allowed;
-    }
-    /**
-     * Gate 3: Does this request path want this action right now?
-     * Plain meaning: checks route-specific intent from routingDecision.
-     * Example: search expansion is skipped when routing says allowSearch=false.
-     */
-    canExecuteRoute(action) {
-        const routing = this.context.analysis?.routingDecision;
-        switch (action) {
-            case "search-expand":
-                return routing?.allowSearch ?? true;
-            case "transform":
-                return routing?.allowTransform ?? true;
-            case "research":
-                return routing?.allowResearch ?? false;
-            default:
-                return true;
-        }
-    }
     /* ----------------------------------- */
     /* ------------- helpers ------------- */
     /* ----------------------------------- */
@@ -1433,6 +1408,68 @@ export class MainAgent {
             console.log(`[USER OUTPUT] ${message}`);
         });
     }
+    /**
+     * Ensures workingFiles has file capsules with code for the given paths.
+     * Example: planned verify-relevant files are hydrated before transform starts.
+     */
+    ensureWorkingFilesLoaded(paths, reason) {
+        var _a;
+        (_a = this.context).workingFiles || (_a.workingFiles = []);
+        const indexByPath = new Map(this.context.workingFiles.map(file => [file.path, file]));
+        for (const filePath of paths) {
+            if (!filePath || filePath.startsWith("__research__/"))
+                continue;
+            if (!fs.existsSync(filePath))
+                continue;
+            const existing = indexByPath.get(filePath);
+            if (existing && typeof existing.code === "string" && existing.code.length > 0) {
+                continue;
+            }
+            let code;
+            try {
+                code = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                code = undefined;
+            }
+            if (existing) {
+                existing.code = code;
+                existing.selectionReason || (existing.selectionReason = reason);
+            }
+            else {
+                const capsule = { path: filePath, code, selectionReason: reason };
+                this.context.workingFiles.push(capsule);
+                indexByPath.set(filePath, capsule);
+            }
+        }
+    }
+    /**
+     * Ensures the current task id exists in the active DB before step persistence.
+     * Example: if repo/db context switched, re-create task row and rebind step taskIds.
+     */
+    ensureTaskIdentityForPersistence(db) {
+        var _a;
+        const activeTaskId = this.taskId ?? this.context.task?.id;
+        if (!activeTaskId) {
+            this.taskId = bootTaskForRepo(this.context, db, this.logLine.bind(this));
+            this.context.task.id = this.taskId;
+            return;
+        }
+        const row = db.prepare("SELECT id FROM tasks WHERE id = ?").get(activeTaskId);
+        if (row?.id) {
+            this.taskId = activeTaskId;
+            this.context.task.id = activeTaskId;
+            return;
+        }
+        const reboundTaskId = bootTaskForRepo(this.context, db, this.logLine.bind(this));
+        this.taskId = reboundTaskId;
+        this.context.task.id = reboundTaskId;
+        (_a = this.context.task).taskSteps || (_a.taskSteps = []);
+        for (const step of this.context.task.taskSteps) {
+            step.taskId = reboundTaskId;
+        }
+        this.logLine("TASK", "taskId rebound", undefined, `previous=${activeTaskId}, rebound=${reboundTaskId}`);
+    }
 }
 function scoreCandidateFiles(filePaths, relatedFileScores, retrievalQuery) {
     const explicitRefs = extractFileReferences(retrievalQuery, { lowercase: true });

package/dist/agents/fileCheckStep.js

@@ -3,6 +3,7 @@ import { generate } from "../lib/generate.js";
 import { logInputOutput } from "../utils/promptLogHelper.js";
 import { cleanupModule } from "../pipeline/modules/cleanupModule.js";
 import path from "path";
+import { isPathIgnoredByFolderGlobs } from "../fileRules/ignoredPaths.js";
 export async function fileCheckStep(context) {
     var _a;
     context.analysis ?? (context.analysis = {});
@@ -10,9 +11,7 @@ export async function fileCheckStep(context) {
     const intent = context.analysis.intent;
     const planSuggestion = context.analysis.planSuggestion?.text ?? "";
     // Step 1: gather known files from initContext only
-    const knownFiles = new Set([
-        ...(context.initContext?.relatedFiles ?? []),
-    ]);
+    const knownFiles = new Set((context.initContext?.relatedFiles ?? []).filter(filePath => !isPathIgnoredByFolderGlobs(filePath)));
     // Step 2: extract file names from normalizedQuery or planSuggestion
     const extractedFiles = extractFilesFromAnalysis(context.analysis);
     // Step 3: populate focus with safe defaults
@@ -138,16 +137,25 @@ Task:
         // Merge parsed output safely
         if (Array.isArray(parsed.selectedFiles)) {
             const existing = new Set(context.analysis.focus.selectedFiles);
+            const safeSelected = parsed.selectedFiles
+                .filter((f) => typeof f === "string" && knownFiles.has(f) && !isPathIgnoredByFolderGlobs(f));
             context.analysis.focus.selectedFiles = [
                 ...context.analysis.focus.selectedFiles,
-                ...parsed.selectedFiles.filter((f) => !existing.has(f))
+                ...safeSelected.filter((f) => !existing.has(f))
             ];
         }
         if (Array.isArray(parsed.candidateFiles)) {
             const existing = new Set(context.analysis.focus.candidateFiles);
+            const safeCandidates = parsed.candidateFiles
+                .filter((f) => typeof f === "string")
+                .filter((f) => {
+                if (knownFiles.has(f))
+                    return !isPathIgnoredByFolderGlobs(f);
+                return /^[\w\-./]+\.(js|ts|jsx|tsx|py|java|go|rs|cpp|c|cs|md)$/i.test(f);
+            });
             context.analysis.focus.candidateFiles = [
                 ...context.analysis.focus.candidateFiles,
-                ...parsed.candidateFiles.filter((f) => !existing.has(f))
+                ...safeCandidates.filter((f) => !existing.has(f))
             ];
         }
         if (typeof parsed.rationale === "string") {

package/dist/agents/guardPolicy.js

@@ -0,0 +1,43 @@
+/**
+ * Gate 1: capability constraints (execution control).
+ */
+export function canExecutePhase(context, phase) {
+    const constraints = context.executionControl?.constraints;
+    const docsOnly = constraints?.docsOnly ?? false;
+    switch (phase) {
+        case "analysis":
+        case "planning":
+            return !docsOnly;
+        case "transform":
+        case "write":
+            return constraints?.allowFileWrites ?? false;
+        default:
+            return false;
+    }
+}
+/**
+ * Gate 2: scope constraints (none/single/multi/repo-wide).
+ */
+export function canExecuteScope(context, phase) {
+    const scope = context.analysis?.scopeType ?? "repo-wide";
+    if (scope === "none") {
+        return phase === "analysis" || phase === "planning";
+    }
+    return true;
+}
+/**
+ * Gate 3: route constraints (dynamic routing decisions).
+ */
+export function canExecuteRoute(context, action) {
+    const routing = context.analysis?.routingDecision;
+    switch (action) {
+        case "search-expand":
+            return routing?.allowSearch ?? true;
+        case "transform":
+            return routing?.allowTransform ?? true;
+        case "research":
+            return routing?.allowResearch ?? false;
+        default:
+            return true;
+    }
+}

package/dist/fileRules/ignoredPaths.js

@@ -43,3 +43,20 @@ export const IGNORED_FOLDER_GLOBS = [
     '**/debug.log',
     '**/Dockerfile',
 ];
+export const IGNORED_DIR_NAMES = Array.from(new Set(IGNORED_FOLDER_GLOBS
+    .map((pattern) => {
+    const match = pattern.match(/^\*\*\/([^*\/]+)\/\*\*$/);
+    return match?.[1];
+})
+    .filter((name) => !!name)));
+/**
+ * Coarse path guard used by runtime search/selection fallback paths.
+ * Matches the same ignore-glob intent used during indexing.
+ */
+export function isPathIgnoredByFolderGlobs(filePath) {
+    const normalizedPath = String(filePath ?? "").replace(/\\/g, "/");
+    return IGNORED_FOLDER_GLOBS.some((pattern) => {
+        const cleanPattern = pattern.replace(/^\*\*\/?/, "").replace(/\/\*\*$/, "");
+        return cleanPattern.length > 0 && normalizedPath.includes(cleanPattern);
+    });
+}

package/dist/pipeline/modules/fileSearchModule.js

@@ -1,11 +1,12 @@
 // File: src/modules/fileSearchModule.ts
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import path from "path";
 import fs from "fs";
 import { plannerSearchFiles } from "../../db/fileIndex.js";
 import { Config } from "../../config.js";
 import { getDbForRepo } from "../../db/client.js";
 import { IGNORED_EXTENSIONS } from "../../fileRules/ignoredExtensions.js";
+import { IGNORED_DIR_NAMES, isPathIgnoredByFolderGlobs } from "../../fileRules/ignoredPaths.js";
 import { logInputOutput } from "../../utils/promptLogHelper.js";
 async function fetchSummariesForPaths(paths) {
     if (paths.length === 0)
@@ -63,14 +64,15 @@ export const fileSearchModule = {
         // -------------------------------------------------
         if (results.length === 0) {
             try {
-                const exclude = IGNORED_EXTENSIONS
-                    .map(ext => `--exclude=*${ext}`)
-                    .join(" ");
-                const stdout = execSync(`grep -ril ${exclude} "${subQuery}" "${repoRoot}"`, { encoding: "utf8" });
+                const excludeExtArgs = IGNORED_EXTENSIONS.map(ext => `--exclude=*${ext}`);
+                const excludeDirArgs = IGNORED_DIR_NAMES.map(dir => `--exclude-dir=${dir}`);
+                const grepArgs = ["-ril", ...excludeDirArgs, ...excludeExtArgs, subQuery, repoRoot];
+                const stdout = execFileSync("grep", grepArgs, { encoding: "utf8" });
                 results = stdout
                     .split("\n")
                     .filter(Boolean)
-                    .map(f => ({ path: f }));
+                    .map(f => ({ path: f }))
+                    .filter(record => !isPathIgnoredByFolderGlobs(record.path));
             }
             catch (err) {
                 if (err?.status !== 1) {

package/dist/utils/resolveTargetsToFiles.js

@@ -1,8 +1,11 @@
 import fs from "fs/promises";
 import path from "path";
+import { isPathIgnoredByFolderGlobs } from "../fileRules/ignoredPaths.js";
 export async function resolveTargetsToFiles(targets, exts) {
     const files = [];
     for (const target of targets) {
+        if (isPathIgnoredByFolderGlobs(target))
+            continue;
         const stat = await fs.stat(target);
         if (stat.isDirectory()) {
             files.push(...await collectFilesRecursive(target, exts));
@@ -18,6 +21,8 @@ async function collectFilesRecursive(dir, exts) {
     const files = [];
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
+        if (isPathIgnoredByFolderGlobs(fullPath))
+            continue;
         if (entry.isDirectory()) {
             files.push(...await collectFilesRecursive(fullPath, exts));
         }

package/package.json

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