scai 0.1.116 → 0.1.118

package/dist/pipeline/modules/summaryModule.js

@@ -1,41 +1,33 @@
-import { Config } from '../../config.js';
-import { generate } from '../../lib/generate.js';
-import path from 'path';
+import { generate } from "../../lib/generate.js";
+import { logInputOutput } from "../../utils/promptLogHelper.js";
 export const summaryModule = {
-    name: 'summary',
-    description: 'Generates a general summary of any file content.',
-    run: async ({ content, filepath }) => {
-        const model = Config.getModel();
-        const ext = filepath ? path.extname(filepath).toLowerCase() : '';
-        const filename = filepath ? path.basename(filepath) : '';
+    name: "summary",
+    description: "Generates a general summary of any file content.",
+    groups: ["analysis"],
+    run: async (input) => {
+        // ✅ Only care about content now
+        const contentStr = typeof input.content === "string"
+            ? input.content
+            : JSON.stringify(input.content ?? "", null, 2);
+        // ❌ Removed filepath/ext/filename extraction
         const prompt = `
 You are an assistant specialized in summarizing files.
 
-Your task is to summarize the contents of the following file as clearly and concisely as possible.
+Your task is to summarize the following content as clearly and concisely as possible:
 
-File: ${filename}
-Extension: ${ext}
-
-📋 Instructions:
-- Identify the main topic and purpose of the file
-- Summarize key content and sections
-- Mention any technical, legal, or structural info if relevant
-- Do NOT include the raw content or repeat lines from it
-- Return a human-readable bullet-point summary
-
---- FILE CONTENT START ---
-${content}
---- FILE CONTENT END ---
-    `.trim();
-        const response = await generate({ content: prompt, filepath });
-        if (response.content) {
-            response.summary = response.content;
-            console.log('\n📝 Summary:\n');
-            console.log(response.summary);
-        }
-        else {
-            console.warn('⚠️ No summary generated.');
-        }
-        return response;
-    }
+${contentStr}
+`.trim();
+        const response = await generate({
+            content: prompt,
+            query: ""
+        });
+        const summary = response.data ?? "⚠️ No summary generated.";
+        const output = {
+            query: input.query, // keep query for context
+            content: '',
+            data: { summary }, // ❌ no filepath
+        };
+        logInputOutput("summary", "output", output.data);
+        return output;
+    },
 };

package/dist/pipeline/modules/writeFileModule.js

@@ -0,0 +1,86 @@
+// File: src/modules/writeFileModule.ts
+import fs from "fs/promises";
+import chalk from "chalk";
+import { normalizePath } from "../../utils/contentUtils.js";
+import { logInputOutput } from "../../utils/promptLogHelper.js";
+export const writeFileModule = {
+    name: "writeFile",
+    description: "Writes materialized file outputs from codeTransformModule to disk. " +
+        "Only writes files specified in the current plan step.",
+    groups: ["finalize"],
+    run: async (input) => {
+        var _a;
+        const context = input.context;
+        const mode = input.data?.mode ?? "overwrite";
+        if (!context) {
+            return {
+                query: input.query,
+                data: { writeMode: mode, writtenFiles: [], errors: ["Missing execution context"] },
+            };
+        }
+        const step = context.currentStep;
+        if (!step) {
+            return {
+                query: input.query,
+                data: { writeMode: mode, writtenFiles: [], errors: ["No current step in context"] },
+            };
+        }
+        // Determine target file(s) from the current step
+        const targetFiles = [];
+        if (step.targetFile)
+            targetFiles.push(step.targetFile);
+        if (Array.isArray(step.targetFiles))
+            targetFiles.push(...step.targetFiles);
+        if (!targetFiles.length) {
+            return {
+                query: input.query,
+                data: { writeMode: mode, writtenFiles: [], errors: ["No targetFile(s) specified in current step"] },
+            };
+        }
+        // Filter codeTransformArtifacts to only the target file(s)
+        const allFiles = context.execution?.codeTransformArtifacts?.files ?? [];
+        const filesToWrite = allFiles.filter(f => targetFiles.includes(f.filePath));
+        if (!filesToWrite.length) {
+            return {
+                query: input.query,
+                data: { writeMode: mode, writtenFiles: [], errors: ["No transformed files found for targetFile(s)"] },
+            };
+        }
+        const writtenFiles = [];
+        const errors = [];
+        for (const f of filesToWrite) {
+            const filePath = normalizePath(f.filePath);
+            if (!filePath) {
+                errors.push(`Invalid filePath: ${f.filePath}`);
+                continue;
+            }
+            if (typeof f.content !== "string" || !f.content.trim()) {
+                errors.push(`No content to write for ${filePath}`);
+                continue;
+            }
+            try {
+                await fs.writeFile(filePath, f.content, "utf-8");
+                console.log(chalk.green(`✅ Written: ${filePath}`));
+                writtenFiles.push(filePath);
+            }
+            catch (err) {
+                console.error(chalk.red(`❌ Failed writing ${filePath}:`), err);
+                errors.push(`${filePath}: ${err.message}`);
+            }
+        }
+        // Mark only the files we just wrote as touched
+        context.plan ?? (context.plan = {});
+        (_a = context.plan).touchedFiles ?? (_a.touchedFiles = []);
+        for (const file of writtenFiles) {
+            if (!context.plan.touchedFiles.includes(file)) {
+                context.plan.touchedFiles.push(file);
+            }
+        }
+        const output = {
+            query: input.query,
+            data: { writeMode: mode, writtenFiles, errors },
+        };
+        logInputOutput("writeFile", "output", output.data);
+        return output;
+    },
+};

package/dist/pipeline/registry/moduleRegistry.js

@@ -1,110 +1,55 @@
-import { addCommentsModule } from '../modules/commentModule.js';
-import { cleanupModule } from '../modules/cleanupModule.js';
-import { summaryModule } from '../modules/summaryModule.js';
-import { generateTestsModule } from '../modules/generateTestsModule.js';
-import { commitSuggesterModule } from '../modules/commitSuggesterModule.js';
-import { changelogModule } from '../modules/changeLogModule.js';
-import { cleanGeneratedTestsModule } from '../modules/cleanGeneratedTestsModule.js';
-import { preserveCodeModule } from '../modules/preserveCodeModule.js';
-import { runTestsModule } from '../modules/runTestsModule.js';
-import { repairTestsModule } from '../modules/repairTestsModule.js';
-// Built-in modules with metadata
+import { contextReviewModule } from "../modules/contextReviewModule.js";
+import { finalAnswerModule } from "../modules/finalAnswerModule.js";
+import { writeFileModule } from "../modules/writeFileModule.js";
+import { fileSearchModule } from "../modules/fileSearchModule.js";
+import { cleanupModule } from "../modules/cleanupModule.js";
+import { summaryModule } from "../modules/summaryModule.js";
+import { addCommentsModule } from "../modules/commentModule.js";
+import { codeTransformModule } from "../modules/codeTransformModule.js";
+/**
+ * Active built-in modules — all use ModuleIO for input/output.
+ */
 export const builtInModules = {
-    comments: {
-        ...addCommentsModule,
-        group: 'documentation',
-        dependencies: {
-            after: ['cleanComments'], // run cleanComments after comments
-        },
-    },
-    cleanComments: {
-        ...preserveCodeModule,
-        group: 'documentation',
-    },
-    cleanup: {
-        ...cleanupModule,
-        group: 'maintenance',
-    },
-    summary: {
-        ...summaryModule,
-        group: 'documentation',
-    },
-    tests: {
-        ...generateTestsModule,
-        group: 'testing',
-        dependencies: {
-            after: ['cleanTests'], // run cleanTests after tests
-        },
-    },
-    cleanTests: {
-        ...cleanGeneratedTestsModule,
-        group: 'testing',
-    },
-    runTests: {
-        ...runTestsModule,
-        group: 'testing',
-        dependencies: {
-            before: ['tests'], // must exist after tests are generated
-            after: ['cleanTests'], // run after cleaning
-        },
-    },
-    repairTests: {
-        ...repairTestsModule,
-        group: 'testing',
-        dependencies: {
-            after: ['runTests'], // repair runs after tests have been executed
-        },
-    },
-    suggest: {
-        ...commitSuggesterModule,
-        group: 'git',
-    },
-    changelog: {
-        ...changelogModule,
-        group: 'git',
-    },
+    fileSearch: fileSearchModule,
+    summary: summaryModule,
+    contextReview: contextReviewModule,
+    // analysis (as agent options?)
+    codeTransform: codeTransformModule,
+    cleanup: cleanupModule,
+    comments: addCommentsModule,
+    writeFile: writeFileModule,
+    finalAnswer: finalAnswerModule,
 };
-// Get module by name
+/**
+ * Get module by name.
+ */
 export function getModuleByName(name) {
     return builtInModules[name];
 }
-// Return module metadata for CLI or UI
+/**
+ * List available modules for CLI or UI display.
+ */
 export function listAvailableModules() {
-    return Object.values(builtInModules).map(({ name, description, group, dependencies }) => ({
+    return Object.entries(builtInModules).map(([name, mod]) => ({
         name,
-        description: description || 'No description available',
-        group,
-        dependencies,
+        description: mod.description ?? "No description available",
     }));
 }
 /**
- * Resolve module execution order including before/after dependencies.
- * Returns a unique ordered array of PromptModuleMeta.
+ * Resolve modules from a list of names.
+ * Returns a unique ordered array of modules.
  */
-export function resolveModuleOrder(moduleNames) {
+export function resolveModulesByNames(names) {
+    const seen = new Set();
     const resolved = [];
-    const visited = new Set();
-    function visit(name) {
-        if (visited.has(name))
-            return;
+    for (const name of names) {
+        if (seen.has(name))
+            continue;
         const mod = getModuleByName(name);
-        if (!mod)
-            return;
-        // Handle before dependencies first
-        if (mod.dependencies?.before) {
-            for (const dep of mod.dependencies.before)
-                visit(dep);
-        }
-        // Add the module itself
-        resolved.push(mod);
-        visited.add(name);
-        // Handle after dependencies
-        if (mod.dependencies?.after) {
-            for (const dep of mod.dependencies.after)
-                visit(dep);
+        if (mod) {
+            resolved.push(mod);
+            seen.add(name);
         }
     }
-    for (const name of moduleNames)
-        visit(name);
     return resolved;
 }

package/dist/pipeline/runModulePipeline.js

@@ -1,27 +1,30 @@
-import chalk from 'chalk';
-export async function runModulePipeline(modules, input) {
-    let current = input;
-    const isDebug = false;
+export async function runModulePipeline(modules, initialInput) {
+    const logPrefix = `[runModulePipeline]`;
+    console.log(`${logPrefix} 🚀 Starting pipeline with ${modules.length} module(s)`);
+    // Copy initial input
+    let currentIO = { ...initialInput };
     for (const mod of modules) {
         try {
-            if (isDebug)
-                console.log(current.filepath);
-            const response = await mod.run(current);
-            console.log(`⚙️ Running: ${mod.name}`);
-            if (isDebug) {
-                console.log(chalk.yellow('➡️ Output:', response.content));
+            const output = await mod.run(currentIO);
+            // Validate shape
+            if (!output) {
+                throw new Error(`Module '${mod.name}' returned empty output`);
             }
-            // Safeguard to preserve filepath + originalContent
-            current = {
-                ...response,
-                originalContent: current.originalContent,
-                filepath: current.filepath,
+            // --- FIX: Pipeline semantics ---
+            // Next module receives:
+            // - same query
+            // - content = previous module's data
+            // - (data is the last produced data only, never merged)
+            currentIO = {
+                query: currentIO.query,
+                content: output.data, // data -> content handoff
+                data: '',
             };
+            console.log(`${logPrefix} 🔁 '${mod.name}' → content replaced with data`);
         }
-        catch (error) {
-            console.error(`❌ Error in ${mod.name}:`, error instanceof Error ? error.message : error);
-            throw new Error(`Pipeline failed at module ${mod.name}`);
+        catch (err) {
+            console.error(`${logPrefix} ❌ Module '${mod.name}' failed:`, err instanceof Error ? err.message : err);
         }
     }
-    return current;
+    return currentIO;
 }

package/dist/scripts/dbcheck.js

@@ -1,119 +1,184 @@
 import Database from "better-sqlite3";
 import path from "path";
 import os from "os";
-import { Config } from "../config.js";
 import fs from "fs";
+import { execSync } from "child_process";
+import { Config } from "../config.js";
+/* ───────────────────────── bootstrap ───────────────────────── */
 const cfg = Config.getRaw();
 const repoKey = cfg.activeRepo;
 if (!repoKey) {
-    console.error("❌ No active repo found. Use `scai set-index` to set one.");
+    console.error("❌ No active repo found. Use `scai set-index`.");
     process.exit(1);
 }
 const repoName = path.basename(repoKey);
 const scaiRepoRoot = path.join(os.homedir(), ".scai", "repos", repoName);
 const dbPath = path.join(scaiRepoRoot, "db.sqlite");
 if (!fs.existsSync(dbPath)) {
-    console.error(`❌ No database found at ${dbPath}`);
+    console.error(`❌ DB not found: ${dbPath}`);
     process.exit(1);
 }
 const db = new Database(dbPath);
-// Utility to log simple table stats
-function tableStats(table, column) {
-    const total = db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get().count;
-    let extra = "";
-    if (column) {
-        const nonNull = db.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE ${column} IS NOT NULL AND ${column} != ''`).get().count;
-        extra = ` | Non-null ${column}: ${nonNull}`;
-    }
-    console.log(`📊 ${table}: ${total}${extra}`);
+/* ───────────────────────── helpers ───────────────────────── */
+function tableCount(table) {
+    return db.prepare(`SELECT COUNT(*) AS c FROM ${table}`).get().c;
 }
-// === Files Table ===
-console.log("\n🗂 Table: files");
-tableStats("files", "summary");
-tableStats("files", "embedding");
-const processingStatuses = ["extracted", "skipped", "failed", "unprocessed"];
-for (const status of processingStatuses) {
-    const count = db.prepare(`SELECT COUNT(*) AS count FROM files WHERE processing_status = ?`).get(status).count;
-    console.log(`   Status '${status}': ${count}`);
+function nonEmptyCount(table, col) {
+    return db.prepare(`SELECT COUNT(*) AS c FROM ${table} WHERE ${col} IS NOT NULL AND ${col} != ''`).get().c;
 }
-// === Example Files ===
-const exampleFiles = db.prepare(`
-  SELECT id, filename, substr(summary,1,50) AS summary, substr(embedding,1,50) AS embedding
+function header(title) {
+    console.log(`\n${title}`);
+}
+/* ───────────────────────── files ───────────────────────── */
+header("🗂 files");
+const totalFiles = tableCount("files");
+const filesWithContent = nonEmptyCount("files", "content_text");
+console.log(`📊 total files: ${totalFiles}`);
+console.log(`📄 files with content: ${filesWithContent}`);
+header("⚙️ processing_status");
+const statuses = db.prepare(`
+  SELECT processing_status, COUNT(*) AS count
   FROM files
-  LIMIT 5
+  GROUP BY processing_status
+  ORDER BY count DESC
 `).all();
-console.log("\n🧾 Example Files:");
-exampleFiles.forEach(f => {
-    console.log(`   [${f.id}] ${f.filename} | summary: "${f.summary}" | embedding: "${f.embedding}"`);
-});
-// === FTS5 Check ===
-const ftsExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='files_fts'`).get();
-console.log("\n🔍 FTS5 Table:", ftsExists ? "✅ exists" : "❌ missing");
-// === Functions Table ===
-console.log("\n🧑‍💻 Table: functions");
-tableStats("functions");
-const sampleFuncs = db.prepare(`
-  SELECT id, name, file_id, substr(content,1,50) AS preview
-  FROM functions
-  ORDER BY RANDOM()
-  LIMIT 5
-`).all();
-sampleFuncs.forEach(f => {
-    console.log(`   [${f.id}] ${f.name} (file ${f.file_id}): ${f.preview}`);
-});
-// === Graph Classes Table ===
-console.log("\n🏷 Table: graph_classes");
-tableStats("graph_classes");
-const sampleClasses = db.prepare(`
-  SELECT id, name, file_id, substr(content,1,50) AS preview
-  FROM graph_classes
-  ORDER BY RANDOM()
-  LIMIT 5
-`).all();
-sampleClasses.forEach(c => {
-    console.log(`   [${c.id}] ${c.name} (file ${c.file_id}): ${c.preview}`);
-});
-// === Graph Edges Table ===
-console.log("\n🔗 Table: graph_edges");
-tableStats("graph_edges", "relation");
-// Dynamically get column names
-const columns = db.prepare(`PRAGMA table_info(graph_edges)`).all();
-const colNames = columns.map(c => c.name);
-// Determine source/target ID columns
-const sourceCol = colNames.includes("source_id") ? "source_id" : "source_unique_id";
-const targetCol = colNames.includes("target_id") ? "target_id" : "target_unique_id";
-const sampleEdges = db.prepare(`
-  SELECT id, source_type, ${sourceCol} AS source_id,
-         target_type, ${targetCol} AS target_id,
-         relation
-  FROM graph_edges
+statuses.forEach(s => console.log(`   ${s.processing_status ?? "NULL"}: ${s.count}`));
+/* ───────────────────────── FTS ───────────────────────── */
+header("🔍 files_fts");
+const ftsExists = db
+    .prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='files_fts'`)
+    .get();
+if (!ftsExists) {
+    console.log("❌ files_fts missing — search is broken");
+}
+else {
+    const cols = db.prepare(`PRAGMA table_info(files_fts)`).all();
+    const hasContentText = cols.some(c => c.name === "content_text");
+    if (!hasContentText) {
+        console.log("❌ files_fts.content_text missing");
+    }
+    else {
+        const indexed = nonEmptyCount("files_fts", "content_text");
+        console.log(`📦 indexed rows with content_text: ${indexed}`);
+        const sample = db.prepare(`
+      SELECT filename, substr(content_text,1,80) AS preview
+      FROM files_fts
+      WHERE files_fts MATCH 'function'
+      LIMIT 3
+    `).all();
+        if (sample.length === 0) {
+            console.log("⚠️ no FTS hits for 'function'");
+        }
+        else {
+            console.log("✅ FTS sample:");
+            sample.forEach(r => console.log(`   ${r.filename} | "${r.preview}"`));
+        }
+    }
+}
+/* ───────────────────────── folder capsules ───────────────────────── */
+header("📁 folder_capsules");
+console.log(`📊 total capsules: ${tableCount("folder_capsules")}`);
+const emptyCapsules = db.prepare(`
+  SELECT COUNT(*) AS c
+  FROM folder_capsules
+  WHERE capsule_json IS NULL OR capsule_json = ''
+`).get();
+if (emptyCapsules.c > 0) {
+    console.log(`⚠️ ${emptyCapsules.c} capsules have empty JSON`);
+}
+const sampleCaps = db.prepare(`
+  SELECT path, depth, confidence, source_file_count, capsule_json
+  FROM folder_capsules
   ORDER BY RANDOM()
   LIMIT 5
 `).all();
-sampleEdges.forEach(e => {
-    console.log(`   [${e.id}] ${e.source_type}(${e.source_id}) -[${e.relation}]-> ${e.target_type}(${e.target_id})`);
+sampleCaps.forEach(c => {
+    let parsed = null;
+    try {
+        parsed = JSON.parse(c.capsule_json);
+    }
+    catch { }
+    console.log(`   ${c.path}`);
+    console.log(`      depth=${c.depth} confidence=${c.confidence} files=${c.source_file_count}`);
+    if (parsed) {
+        console.log(`      roles=${parsed.roles?.length ?? 0} ` +
+            `concerns=${parsed.concerns?.length ?? 0} ` +
+            `keyFiles=${parsed.keyFiles?.length ?? 0}`);
+    }
 });
-// === Tags Tables ===
-console.log("\n🏷 Table: graph_tags_master");
-tableStats("graph_tags_master");
-const sampleTags = db.prepare(`
-  SELECT id, name
-  FROM graph_tags_master
+/* ───────────────────────── functions ───────────────────────── */
+header("🧑‍💻 functions");
+console.log(`📊 total functions: ${tableCount("functions")}`);
+const funcSamples = db.prepare(`
+  SELECT id, name, file_id, substr(content,1,60) AS preview
+  FROM functions
   ORDER BY RANDOM()
   LIMIT 5
 `).all();
-sampleTags.forEach(t => {
-    console.log(`   [${t.id}] ${t.name}`);
-});
-console.log("\n🔖 Table: graph_entity_tags");
-tableStats("graph_entity_tags");
-const sampleEntityTags = db.prepare(`
-  SELECT id, entity_type, entity_unique_id AS entity_id, tag_id
-  FROM graph_entity_tags
-  ORDER BY RANDOM()
-  LIMIT 5
+funcSamples.forEach(f => console.log(`   [${f.id}] ${f.name} (file ${f.file_id}) "${f.preview}"`));
+/* ───────────────────────── graph (KG) ───────────────────────── */
+header("🏷 graph_classes");
+console.log(`📊 total classes: ${tableCount("graph_classes")}`);
+header("🔗 graph_edges");
+console.log(`📊 total edges: ${tableCount("graph_edges")}`);
+const danglingFuncs = db.prepare(`
+  SELECT e.id
+  FROM graph_edges e
+  WHERE e.source_type='function'
+    AND NOT EXISTS (SELECT 1 FROM functions f WHERE f.unique_id = e.source_unique_id)
+  UNION
+  SELECT e.id
+  FROM graph_edges e
+  WHERE e.target_type='function'
+    AND NOT EXISTS (SELECT 1 FROM functions f WHERE f.unique_id = e.target_unique_id)
+  LIMIT 10
 `).all();
-sampleEntityTags.forEach(et => {
-    console.log(`   [${et.id}] ${et.entity_type}(${et.entity_id}) -> tag ${et.tag_id}`);
-});
-console.log("\n✅ DB check completed.\n");
+if (danglingFuncs.length === 0) {
+    console.log("✅ no dangling function edges");
+}
+else {
+    console.log(`❌ dangling function edges: ${danglingFuncs.length}`);
+}
+/* ───────────────────────── Graphviz ───────────────────────── */
+header("🧩 graphviz");
+try {
+    const edges = db.prepare(`
+    SELECT source_type, source_unique_id, target_type, target_unique_id, relation
+    FROM graph_edges
+    LIMIT 300
+  `).all();
+    if (edges.length === 0) {
+        console.log("⚠️ no edges — skipping export");
+    }
+    else {
+        const lines = [
+            "digraph G {",
+            "  rankdir=LR;",
+            '  node [shape=box, style=filled, color="#eaeaea"];'
+        ];
+        for (const e of edges) {
+            const s = `${e.source_type}_${e.source_unique_id}`.replace(/[^a-zA-Z0-9_]/g, "_");
+            const t = `${e.target_type}_${e.target_unique_id}`.replace(/[^a-zA-Z0-9_]/g, "_");
+            const label = (e.relation ?? "").replace(/"/g, "'");
+            lines.push(`  ${s} -> ${t} [label="${label}"];`);
+        }
+        lines.push("}");
+        const outDir = path.join(scaiRepoRoot, "graphs");
+        fs.mkdirSync(outDir, { recursive: true });
+        const dot = path.join(outDir, "graph-overview.dot");
+        const png = path.join(outDir, "graph-overview.png");
+        fs.writeFileSync(dot, lines.join("\n"));
+        console.log(`✅ dot written: ${dot}`);
+        try {
+            execSync(`dot -Tpng "${dot}" -o "${png}"`);
+            console.log(`✅ png written: ${png}`);
+        }
+        catch {
+            console.log("⚠️ graphviz not installed — png skipped");
+        }
+    }
+}
+catch (err) {
+    console.error("❌ graphviz export failed", err);
+}
+console.log("\n✅ DB check complete\n");