scai 0.1.126 → 0.1.127

package/dist/agents/MainAgent.js

@@ -1,6 +1,5 @@
 import { builtInModules } from "../pipeline/registry/moduleRegistry.js";
 import { logInputOutput } from "../utils/promptLogHelper.js";
-import { planResolverStep } from "./planResolverStep.js";
 import { infoPlanGen } from "./infoPlanGenStep.js";
 import { understandIntentStep } from "./understandIntentStep.js";
 import { structuralAnalysisStep } from "./structuralAnalysisStep.js";
@@ -13,6 +12,7 @@ import { selectRelevantSourcesStep } from "./selectRelevantSourcesStep.js";
 import { transformPlanGenStep } from "./transformPlanGenStep.js";
 import { finalPlanGenStep } from "./finalPlanGenStep.js";
 import { Spinner } from "../lib/spinner.js";
+import { getDbForRepo } from "../db/client.js";
 /* ───────────────────────── helpers ───────────────────────── */
 function startTimer() {
     const start = Date.now();
@@ -98,26 +98,17 @@ export class MainAgent {
             const t = startTimer();
             await understandIntentStep.run({ context: this.context });
             logLine("BOOT", "understandIntent", t());
-        }
-        /* ROUTE */
-        {
-            const t = startTimer();
-            await planResolverStep.run(this.context);
-            logLine("ROUTE", "planResolver", t());
-        }
-        const routing = this.context.analysis?.routingDecision;
-        if (routing?.decision === "final-answer" && routing.answer) {
-            this.spinner.stop();
-            logLine("RUN", "complete", stopRun());
-            userOutput("All input/output logs can be found at ~/.scai/input_output.log");
-            return {
-                query: this.query,
-                data: {
-                    finalAnswer: routing.answer,
-                    source: "planResolver"
-                },
-                context: this.context
-            };
+            // >>> TASK PERSISTENCE ADDITION <<<
+            // create a task immediately after boot
+            const db = getDbForRepo();
+            const now = new Date().toISOString();
+            const userQuery = this.context.initContext?.userQuery ?? "unknown query";
+            const result = db.prepare(`
+                INSERT INTO tasks (initial_query, created_at, updated_at)
+                VALUES (?, ?, ?)
+            `).run(userQuery, now, now);
+            this.taskId = result.lastInsertRowid;
+            logLine("TASK", `created task id=${this.taskId}"`);
         }
         // =====================================================
         // INFORMATION ACQUISITION PHASE

package/dist/agents/finalPlanGenStep.js

@@ -60,10 +60,21 @@ Example format:
                 ? genOutput.data
                 : JSON.stringify(genOutput.data ?? '{}');
             const cleaned = await cleanupModule.run({ query: intentText, content: raw });
-            const jsonString = typeof cleaned.content === 'string'
-                ? cleaned.content
-                : JSON.stringify(cleaned.content ?? '{}');
-            let plan = JSON.parse(jsonString);
+            let plan = null;
+            if (cleaned.data && typeof cleaned.data === 'object') {
+                // ✅ cleanup succeeded
+                plan = cleaned.data;
+            }
+            else if (typeof cleaned.data === 'string') {
+                // ⚠️ fallback: try extracting JSON
+                const match = cleaned.data.match(/\{[\s\S]*\}/);
+                if (match) {
+                    plan = JSON.parse(match[0]);
+                }
+            }
+            if (!plan || !Array.isArray(plan.steps)) {
+                throw new Error('Invalid final plan structure');
+            }
             if (!plan || !Array.isArray(plan.steps))
                 throw new Error('Invalid final plan structure');
             if (plan.steps.length > MAX_STEPS)

package/dist/agents/planGeneratorStep.js

@@ -70,7 +70,6 @@ Rules:
 }
     `.trim();
         try {
-            console.dir("planGeneratorPrompt: ", prompt);
             const genInput = { query: intentText ?? '', content: prompt };
             const genOutput = await generate(genInput);
             const llmOutput = typeof genOutput.data === 'string'

package/dist/agents/transformPlanGenStep.js

@@ -31,8 +31,8 @@ or modifications in the system to achieve the intended task.
 Intent / task description:
 ${intentText}
 
-If the intent indicates that this is NOT a coding, refactoring, or inline commenting task, 
-then return an empty plan object with an empty "steps" array: 
+If the intent indicates that this is NOT a coding, refactoring, or inline commenting task,
+then return an empty plan object with an empty "steps" array:
 { "steps": [] }
 
 Allowed actions (transformation only):
@@ -50,12 +50,11 @@ ${JSON.stringify(context.analysis.focus?.relevantFiles ?? {}, null, 2)}
 Only perform transformations that are safe based on the existing analysis.
 
 ⚡ Phase guidance:
-- Actions are grouped into phases: info, transform, finalize.
 - Only include transform steps in this phase.
 - Include a 'writeFile' step for each 'codeTransform' to persist changes to disk.
 - Each step must include: "action", "targetFile" (optional), "description", "metadata"
 
-❌ IMPORTANT: Do NOT include "info" steps here. Only plan actual code transformations.
+❌ IMPORTANT: Do NOT include "info" steps here.
 
 Return a strictly valid JSON plan:
 
@@ -72,14 +71,36 @@ Return a strictly valid JSON plan:
                 ? genOutput.data
                 : JSON.stringify(genOutput.data ?? '{}');
             const cleaned = await cleanupModule.run({ query: intentText, content: raw });
-            const jsonString = typeof cleaned.content === 'string'
-                ? cleaned.content
-                : JSON.stringify(cleaned.content ?? '{}');
-            let plan = JSON.parse(jsonString);
-            if (!plan || !Array.isArray(plan.steps))
+            let plan = null;
+            // --- Parse strategy ---
+            if (cleaned.data && typeof cleaned.data === 'object') {
+                console.log('[transformPlanGen][debug] Using parsed JSON from cleanupModule');
+                plan = cleaned.data;
+            }
+            else if (typeof cleaned.data === 'string') {
+                console.log('[transformPlanGen][debug] Attempting JSON extraction fallback');
+                const match = cleaned.data.match(/\{[\s\S]*\}/);
+                if (match) {
+                    try {
+                        plan = JSON.parse(match[0]);
+                        console.log('[transformPlanGen][debug] Fallback JSON.parse succeeded');
+                    }
+                    catch (err) {
+                        console.error('[transformPlanGen][debug] Fallback JSON.parse FAILED', err);
+                    }
+                }
+                else {
+                    console.warn('[transformPlanGen][debug] No JSON object found in string');
+                }
+            }
+            // --- Final validation (single source of truth) ---
+            if (!plan || !Array.isArray(plan.steps)) {
+                console.error('[transformPlanGen][debug] Invalid or missing plan.steps', plan);
                 throw new Error('Invalid transform plan structure');
-            if (plan.steps.length > MAX_STEPS)
+            }
+            if (plan.steps.length > MAX_STEPS) {
                 plan.steps = plan.steps.slice(0, MAX_STEPS);
+            }
             // Map groups & metadata
             plan.steps = plan.steps.map(step => {
                 const actionDef = PLAN_ACTIONS.find(a => a.action === step.action);

package/dist/db/schema.js

@@ -25,10 +25,34 @@ export function initSchema() {
       content='files', 
       content_rowid='id'
     );
+  `);
+    // --- Tasks table for collaborative workflows ---
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+
+      -- identity & lifecycle
+      status TEXT NOT NULL DEFAULT 'active',  -- active | paused | completed | abandoned
+
+      -- human-facing
+      initial_query TEXT NOT NULL,            -- raw user query
+      summary TEXT,                           -- evolving short description
+
+      -- resolved collaboration state
+      agreed_intent TEXT,
+      constraints_json TEXT,                  -- JSON array of constraints
+      file_scope_json TEXT,                   -- JSON array of file paths
+
+      -- bookkeeping
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
   `);
     // --- Folder capsules ---
     db.exec(`
-  CREATE TABLE IF NOT EXISTS folder_capsules (
+  CREATE TABLE IF NOT EXISTS folder_capsules(
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     path TEXT UNIQUE NOT NULL,
     depth INTEGER NOT NULL,
@@ -43,79 +67,79 @@ export function initSchema() {
 
   CREATE INDEX IF NOT EXISTS idx_folder_capsules_depth
     ON folder_capsules(depth);
-`);
+  `);
     // --- Functions table ---
     db.exec(`
-    CREATE TABLE IF NOT EXISTS functions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      file_id INTEGER REFERENCES files(id),
-      name TEXT,
-      unique_id TEXT UNIQUE,  -- e.g. "buildContextualPrompt@cli/src/utils/buildContextualPrompt.ts"
+    CREATE TABLE IF NOT EXISTS functions(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id INTEGER REFERENCES files(id),
+    name TEXT,
+    unique_id TEXT UNIQUE, --e.g. "buildContextualPrompt@cli/src/utils/buildContextualPrompt.ts"
       start_line INTEGER,
-      end_line INTEGER,
-      content TEXT,
-      lang TEXT
-    );
+    end_line INTEGER,
+    content TEXT,
+    lang TEXT
+  );
 
     CREATE INDEX IF NOT EXISTS idx_functions_file_id ON functions(file_id);
     CREATE INDEX IF NOT EXISTS idx_functions_unique_id ON functions(unique_id);
   `);
     // --- Graph-specific additions ---
     db.exec(`
-    CREATE TABLE IF NOT EXISTS graph_classes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      file_id INTEGER REFERENCES files(id),
-      name TEXT,
-      unique_id TEXT UNIQUE,
-      start_line INTEGER,
-      end_line INTEGER,
-      content TEXT,
-      lang TEXT
-    );
+    CREATE TABLE IF NOT EXISTS graph_classes(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id INTEGER REFERENCES files(id),
+    name TEXT,
+    unique_id TEXT UNIQUE,
+    start_line INTEGER,
+    end_line INTEGER,
+    content TEXT,
+    lang TEXT
+  );
 
     CREATE INDEX IF NOT EXISTS idx_graph_classes_file_id ON graph_classes(file_id);
     CREATE INDEX IF NOT EXISTS idx_graph_classes_unique_id ON graph_classes(unique_id);
   `);
     db.exec(`
-    CREATE TABLE IF NOT EXISTS graph_edges (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      source_type TEXT NOT NULL,
-      source_unique_id TEXT NOT NULL,
-      target_type TEXT NOT NULL,
-      target_unique_id TEXT NOT NULL,
-      relation TEXT NOT NULL
-    );
+    CREATE TABLE IF NOT EXISTS graph_edges(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_type TEXT NOT NULL,
+    source_unique_id TEXT NOT NULL,
+    target_type TEXT NOT NULL,
+    target_unique_id TEXT NOT NULL,
+    relation TEXT NOT NULL
+  );
 
     CREATE INDEX IF NOT EXISTS idx_graph_edges_source ON graph_edges(source_type, source_unique_id);
     CREATE INDEX IF NOT EXISTS idx_graph_edges_target ON graph_edges(target_type, target_unique_id);
     CREATE INDEX IF NOT EXISTS idx_graph_edges_relation ON graph_edges(relation);
   `);
     db.exec(`
-    CREATE TABLE IF NOT EXISTS graph_tags_master (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT UNIQUE NOT NULL
-    );
+    CREATE TABLE IF NOT EXISTS graph_tags_master(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL
+  );
 
-    CREATE TABLE IF NOT EXISTS graph_entity_tags (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      entity_type TEXT NOT NULL,
-      entity_unique_id TEXT NOT NULL,
-      tag_id INTEGER NOT NULL REFERENCES graph_tags_master(id),
-      UNIQUE(entity_type, entity_unique_id, tag_id)
-    );
+    CREATE TABLE IF NOT EXISTS graph_entity_tags(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entity_type TEXT NOT NULL,
+    entity_unique_id TEXT NOT NULL,
+    tag_id INTEGER NOT NULL REFERENCES graph_tags_master(id),
+    UNIQUE(entity_type, entity_unique_id, tag_id)
+  );
 
     CREATE INDEX IF NOT EXISTS idx_graph_entity_tags_entity ON graph_entity_tags(entity_type, entity_unique_id);
     CREATE INDEX IF NOT EXISTS idx_graph_entity_tags_tag ON graph_entity_tags(tag_id);
   `);
     db.exec(`
-    CREATE TABLE IF NOT EXISTS summaries (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      path TEXT UNIQUE,
-      type TEXT NOT NULL CHECK (type IN ('folder','project')),
-      summary TEXT,
-      last_generated TEXT,
-      child_latest_modified TEXT
-    );
+    CREATE TABLE IF NOT EXISTS summaries(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT UNIQUE,
+    type TEXT NOT NULL CHECK(type IN('folder', 'project')),
+    summary TEXT,
+    last_generated TEXT,
+    child_latest_modified TEXT
+  );
 
     CREATE INDEX IF NOT EXISTS idx_summaries_type ON summaries(type);
     CREATE INDEX IF NOT EXISTS idx_summaries_path ON summaries(path);

package/dist/pipeline/modules/cleanupModule.js

@@ -1,84 +1,55 @@
 // File: src/modules/cleanupModule.ts
 import chalk from "chalk";
-/** --- Helper: detect noise at top/bottom of content --- */
+/** --- Helper: detect top/bottom fluff/noise --- */
 function isTopOrBottomNoise(line) {
     const trimmed = line.trim();
+    if (!trimmed)
+        return true;
     if (/^```(?:\w+)?$/.test(trimmed))
         return true;
     if (/^<!--.*-->$/.test(trimmed))
         return true;
     const lower = trimmed.toLowerCase();
-    if (!trimmed.startsWith("//") && !trimmed.startsWith("/*")) {
-        return [
-            /^i\s/i,
-            /^here/,
-            /^this/,
-            /^the following/,
-            /^below/,
-            /^in this/,
-            /^we have/,
-            /the code above/,
-            /ensures that/,
-            /it handles/,
-            /used to/,
-            /note that/,
-            /example/,
-            /summary/,
-            /added comments/,
-        ].some((pattern) => pattern.test(lower));
-    }
-    return false;
-}
-/** Extract first object slice { ... } */
-function extractObject(text) {
-    const start = text.indexOf("{");
-    const end = text.lastIndexOf("}");
-    return start !== -1 && end !== -1 && end > start ? text.slice(start, end + 1) : null;
+    return [
+        /^i\s/i,
+        /^here/iu,
+        /^this/iu,
+        /^the following/iu,
+        /^below/iu,
+        /^in this/iu,
+        /^we have/iu,
+        /the code above/iu,
+        /ensures that/iu,
+        /it handles/iu,
+        /used to/iu,
+        /note that/iu,
+        /example/iu,
+        /summary/iu,
+        /added comments/iu,
+    ].some((pattern) => pattern.test(lower));
 }
-/** Extract first array slice [ ... ] */
-function extractArray(text) {
-    const start = text.indexOf("[");
-    const end = text.lastIndexOf("]");
-    return start !== -1 && end !== -1 && end > start ? text.slice(start, end + 1) : null;
+/** --- Extract first JSON object or array slice --- */
+function extractJsonSlice(text) {
+    const objStart = text.indexOf("{");
+    const objEnd = text.lastIndexOf("}");
+    if (objStart !== -1 && objEnd > objStart)
+        return text.slice(objStart, objEnd + 1);
+    const arrStart = text.indexOf("[");
+    const arrEnd = text.lastIndexOf("]");
+    if (arrStart !== -1 && arrEnd > arrStart)
+        return text.slice(arrStart, arrEnd + 1);
+    return null;
 }
-/** Try parsing with fallback slice logic */
+/** --- Try parsing JSON with multiple fallbacks --- */
 function parseJsonWithFallback(content) {
-    const trimmed = content.trim();
-    // --- 1) JSON Array strategy ---
-    if (trimmed.startsWith("[")) {
-        try {
-            return JSON.parse(trimmed);
-        }
-        catch {
-            const slice = extractArray(trimmed);
-            if (slice) {
-                try {
-                    return JSON.parse(slice);
-                }
-                catch { }
-            }
-        }
-    }
-    // --- 2) JSON Object strategy ---
-    if (trimmed.startsWith("{")) {
-        try {
-            return JSON.parse(trimmed);
-        }
-        catch {
-            const slice = extractObject(trimmed);
-            if (slice) {
-                try {
-                    return JSON.parse(slice);
-                }
-                catch { }
-            }
-        }
+    try {
+        return JSON.parse(content);
     }
-    // --- 3) Fallback: if mixed text, extract first object ---
-    const fallbackObj = extractObject(content);
-    if (fallbackObj) {
+    catch { }
+    const slice = extractJsonSlice(content);
+    if (slice) {
         try {
-            return JSON.parse(fallbackObj);
+            return JSON.parse(slice);
         }
         catch { }
     }
@@ -87,7 +58,7 @@ function parseJsonWithFallback(content) {
 /** --- Module --- */
 export const cleanupModule = {
     name: "cleanup",
-    description: "Removes markdown fences, fluff, and reasoning text; extracts valid JSON if possible.",
+    description: "Cleans up AI output, removes noise, and extracts valid JSON if possible.",
     groups: ["transform"],
     async run(input) {
         // --- Normalize input ---
@@ -97,39 +68,30 @@ export const cleanupModule = {
         content = content.replace(/\r\n/g, "\n");
         // --- Trim top/bottom noise ---
         let lines = content.split("\n");
-        while (lines.length && (lines[0].trim() === "" || isTopOrBottomNoise(lines[0])))
+        while (lines.length && isTopOrBottomNoise(lines[0]))
             lines.shift();
-        while (lines.length && (lines[lines.length - 1].trim() === "" || isTopOrBottomNoise(lines[lines.length - 1]))) {
+        while (lines.length && isTopOrBottomNoise(lines[lines.length - 1]))
             lines.pop();
-        }
-        content = lines.join("\n");
-        // --- Strip markdown fences, comments, thinking tags ---
+        content = lines.join("\n").trim();
+        // --- Remove fences, HTML comments, thinking tags ---
         content = content
             .replace(/```(?:json)?/gi, "")
             .replace(/```/g, "")
             .replace(/<!--.*?-->/gs, "")
             .replace(/<think>[\s\S]*?<\/think>/gi, "")
             .trim();
-        // If no JSON markers at all → treat as plain cleaned text
-        if (!content.includes("{") && !content.includes("[")) {
-            return { query: input.query, data: content };
+        // --- Attempt parsing ---
+        let parsed = null;
+        if (content.includes("{") || content.includes("[")) {
+            parsed = parseJsonWithFallback(content);
         }
-        // --- Parse JSON using simplified strategy ---
-        const parsed = parseJsonWithFallback(content);
         if (parsed !== null) {
-            return {
-                query: input.query,
-                content,
-                data: parsed,
-            };
+            return { query: input.query, content, data: parsed };
         }
-        // Clear current line (removes leftover spinner)
-        process.stdout.write('\r\x1b[K');
-        console.warn(chalk.red(" - [cleanupModule] Failed to parse JSON — returning raw content."));
-        return {
-            query: input.query,
-            content,
-            data: content,
-        };
+        // --- Fallback: return raw cleaned text ---
+        // Use console.debug instead of warn so logs are quieter
+        process.stdout.write("\r\x1b[K");
+        console.debug(chalk.yellow(` - [cleanupModule] Could not parse JSON, returning raw content.`));
+        return { query: input.query, content, data: content };
     },
 };

package/dist/scripts/dbcheck.js

@@ -19,6 +19,34 @@ if (!fs.existsSync(dbPath)) {
     process.exit(1);
 }
 const db = new Database(dbPath);
+/* ───────────────────────── tasks ───────────────────────── */
+header("📝 tasks");
+// check if table exists
+const tasksExists = db
+    .prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='tasks'`)
+    .get();
+if (!tasksExists) {
+    console.log("❌ tasks table missing — you need to run initSchema with tasks");
+}
+else {
+    const totalTasks = tableCount("tasks");
+    const tasksWithQuery = nonEmptyCount("tasks", "initial_query");
+    console.log(`📊 total tasks: ${totalTasks}`);
+    console.log(`✏️ tasks with initial_query: ${tasksWithQuery}`);
+    const sampleTasks = db.prepare(`
+    SELECT id, initial_query, status, created_at
+    FROM tasks
+    ORDER BY created_at DESC
+    LIMIT 3
+  `).all();
+    if (sampleTasks.length === 0) {
+        console.log("⚠️ no tasks yet");
+    }
+    else {
+        console.log("✅ sample tasks:");
+        sampleTasks.forEach(t => console.log(`   [${t.id}] "${t.initial_query}" (status=${t.status}, created=${t.created_at})`));
+    }
+}
 /* ───────────────────────── helpers ───────────────────────── */
 function tableCount(table) {
     return db.prepare(`SELECT COUNT(*) AS c FROM ${table}`).get().c;

package/package.json

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