scai 0.1.27 → 0.1.29

package/dist/commands/AskCmd.js

@@ -1,5 +1,7 @@
 import readline from 'readline';
-import { searchFiles } from "../db/fileIndex.js";
+import path from 'path';
+import { searchFiles, queryFiles } from "../db/fileIndex.js";
+import { sanitizeQueryForFts } from "../utils/sanitizeQuery.js";
 import { generate } from "../lib/generate.js";
 export async function runAskCommand(query) {
     if (!query) {
@@ -12,21 +14,43 @@ export async function runAskCommand(query) {
     }
     console.log(`🔍 Searching for: "${query}"\n`);
     const start = Date.now();
-    const results = await searchFiles(query, 5);
+    const semanticResults = await searchFiles(query, 5);
     const duration = Date.now() - start;
-    console.log(`⏱️ searchFiles took ${duration}ms and returned ${results.length} result(s)`);
-    if (results.length > 0) {
-        console.log('📊 Closest files based on semantic similarity:');
-        results.forEach((file, i) => {
-            console.log(`  ${i + 1}. 📄 Path: ${file?.path} | Score: ${file?.score?.toFixed(3)}`);
+    console.log(`⏱️ searchFiles took ${duration}ms and returned ${semanticResults.length} result(s)`);
+    // Also run fallback keyword search
+    const safeQuery = sanitizeQueryForFts(query);
+    const fallbackResults = queryFiles(safeQuery, 10);
+    // Merge semantic and fallback results
+    const seen = new Set();
+    const combinedResults = [];
+    for (const file of semanticResults) {
+        const resolved = path.resolve(file.path);
+        seen.add(resolved);
+        combinedResults.push(file); // Already scored
+    }
+    for (const file of fallbackResults) {
+        const resolved = path.resolve(file.path);
+        if (!seen.has(resolved)) {
+            seen.add(resolved);
+            combinedResults.push({
+                path: file.path,
+                summary: file.summary,
+                score: 0.0, // fallback score
+            });
+        }
+    }
+    if (combinedResults.length > 0) {
+        console.log('📊 Closest files based on semantic + keyword match:');
+        combinedResults.forEach((file, i) => {
+            console.log(`  ${i + 1}. 📄 Path: ${file.path} | Score: ${file.score?.toFixed(3) ?? 'fallback'}`);
         });
     }
     else {
-        console.log('⚠️ No similar embeddings found. Asking the model for context instead...');
+        console.log('⚠️ No similar files found. Asking the model for context only...');
     }
-    // 🧠 Use stored summaries directly
+    // Aggregate summaries
     let allSummaries = '';
-    for (const file of results) {
+    for (const file of combinedResults) {
         if (!file?.summary) {
             console.warn(`⚠️ No summary available for file: ${file?.path}`);
             continue;

package/dist/commands/SummaryCmd.js

@@ -1,54 +1,53 @@
 import fs from 'fs/promises';
 import path from 'path';
 import readline from 'readline';
-import { queryFiles } from '../db/fileIndex.js';
+import { queryFiles, indexFile } from '../db/fileIndex.js';
 import { summaryModule } from '../pipeline/modules/summaryModule.js';
 import { summarizeCode } from '../utils/summarizer.js';
+import { detectFileType } from '../utils/detectFileType.js';
+import { generateEmbedding } from '../lib/generateEmbedding.js';
+import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
+import { db } from '../db/client.js';
 export async function summarizeFile(filepath) {
     let content = '';
-    let summary;
-    let filePathResolved = filepath ? path.resolve(process.cwd(), filepath) : undefined;
-    // Handle case where user provides only a filename (without extension)
-    if (filepath && !path.extname(filepath)) {
-        // Search for matching files using the provided base name
-        const matches = queryFiles(`"${filepath}"`);
+    let filePathResolved;
+    // 📁 Resolve path like `scai find`
+    if (filepath) {
+        const sanitizedQuery = sanitizeQueryForFts(filepath);
+        const matches = queryFiles(sanitizedQuery);
         if (matches.length > 0) {
-            const match = matches[0]; // Get the first match (adjust based on your preference)
-            filePathResolved = path.resolve(process.cwd(), match.path);
+            const topMatch = matches[0];
+            filePathResolved = path.resolve(process.cwd(), topMatch.path);
+            console.log(`🔗 Matched file: ${path.relative(process.cwd(), filePathResolved)}`);
+        }
+        else {
+            console.error(`❌ Could not resolve file from query: "${filepath}"`);
+            return;
         }
     }
-    else if (filepath && path.extname(filepath)) {
-        // Handle case where full filename with extension is provided
-        filePathResolved = path.resolve(process.cwd(), filepath);
-    }
-    // Now, let's search the database for a summary
+    // 📄 Load file content from resolved path
     if (filePathResolved) {
+        const matches = queryFiles(`"${filePathResolved}"`);
+        const match = matches.find(row => path.resolve(row.path) === filePathResolved);
+        if (match?.summary) {
+            console.log(`🧠 Cached summary for ${filepath}:\n`);
+            console.log(summarizeCode(match.summary));
+            return;
+        }
         try {
-            // Try to find an existing summary from the database using the resolved path
-            const matches = queryFiles(`"${filePathResolved}"`);
-            const match = matches.find(row => path.resolve(row.path) === filePathResolved);
-            if (match?.summary) {
-                // If a summary exists in the database, use it
-                console.log(`🧠 Cached summary for ${filepath}:\n`);
-                console.log(summarizeCode(match.summary));
-                return;
-            }
-            // If no cached summary, read the file content
             content = await fs.readFile(filePathResolved, 'utf-8');
         }
         catch (err) {
-            console.error(`❌ Could not process ${filepath}:`, err.message);
+            console.error(`❌ Could not read file: ${filePathResolved}\n${err.message}`);
             return;
         }
     }
     else if (!process.stdin.isTTY) {
-        // If no file path and input comes from stdin (piped content)
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
             terminal: false,
         });
-        // Collect all piped input into the `content` string
         for await (const line of rl) {
             content += line + '\n';
         }
@@ -57,17 +56,27 @@ export async function summarizeFile(filepath) {
         console.error('❌ No file provided and no piped input.\n👉 Usage: scai summ <file> or cat file | scai summ');
         return;
     }
-    // If content is available (from file or stdin)
+    // 🧠 Generate summary and save
     if (content.trim()) {
         console.log('🧪 Generating summary...\n');
-        // Generate a summary using your summarization pipeline
         const response = await summaryModule.run({ content, filepath });
         if (!response.summary) {
             console.warn('⚠️ No summary generated.');
             return;
         }
-        // Print the formatted summary
         console.log(summarizeCode(response.summary));
+        if (filePathResolved) {
+            const fileType = detectFileType(filePathResolved);
+            indexFile(filePathResolved, response.summary, fileType);
+            console.log('💾 Summary saved to local database.');
+            const embedding = await generateEmbedding(response.summary);
+            if (embedding) {
+                db.prepare(`
+          UPDATE files SET embedding = ? WHERE path = ?
+        `).run(JSON.stringify(embedding), filePathResolved.replace(/\\/g, '/'));
+                console.log('📐 Embedding saved to database.');
+            }
+        }
     }
     else {
         console.error('❌ No content provided to summarize.');

package/dist/db/fileIndex.js

@@ -53,17 +53,15 @@ export async function searchFiles(query, topK = 5) {
     const safeQuery = sanitizeQueryForFts(query);
     console.log(`Executing search query in FTS5: ${safeQuery}`);
     const ftsResults = db.prepare(`
-  SELECT fts.rowid AS id, f.path, f.summary, f.type, bm25(files_fts) AS bm25Score
-  FROM files f
-  JOIN files_fts fts ON f.id = fts.rowid
-  WHERE fts.files_fts MATCH ?
-  AND f.embedding IS NOT NULL
-  ORDER BY bm25Score DESC
-  LIMIT ?
-`).all(safeQuery, topK);
+    SELECT fts.rowid AS id, f.path, f.summary, f.type, bm25(files_fts) AS bm25Score, f.embedding
+    FROM files f
+    JOIN files_fts fts ON f.id = fts.rowid
+    WHERE fts.files_fts MATCH ?
+    ORDER BY bm25Score ASC
+    LIMIT ?
+  `).all(safeQuery, 20);
     console.log(`FTS search returned ${ftsResults.length} results`);
     if (ftsResults.length === 0) {
-        console.log('⚠️ No results found from FTS search');
         return [];
     }
     ftsResults.forEach(result => {
@@ -72,36 +70,37 @@ export async function searchFiles(query, topK = 5) {
     const bm25Min = Math.min(...ftsResults.map(r => r.bm25Score));
     const bm25Max = Math.max(...ftsResults.map(r => r.bm25Score));
     const scored = ftsResults.map(result => {
-        try {
-            const embResult = db.prepare(sqlTemplates.fetchEmbeddingTemplate).get({
-                path: result.path,
-            });
-            if (!embResult || typeof embResult.embedding !== 'string') {
-                console.log(`⚠️ No embedding for file: ${result.path}`);
-                return null;
+        let finalScore = 0;
+        let sim = 0;
+        if (result.embedding) {
+            try {
+                const vector = JSON.parse(result.embedding);
+                sim = cosineSimilarity(embedding, vector);
+                const normalizedBm25 = 1 - ((result.bm25Score - bm25Min) / (bm25Max - bm25Min + 1e-5));
+                finalScore = 0.7 * sim + 0.3 * normalizedBm25;
+            }
+            catch (err) {
+                console.error(`❌ Failed to parse embedding for ${result.path}:`, err);
+                finalScore = 0; // fallback
             }
-            const vector = JSON.parse(embResult.embedding);
-            const sim = cosineSimilarity(embedding, vector);
-            const normalizedBm25 = 1 - ((result.bm25Score - bm25Min) / (bm25Max - bm25Min + 1e-5));
-            const finalScore = 0.7 * sim + 0.3 * normalizedBm25;
-            return {
-                path: result.path,
-                summary: result.summary,
-                score: finalScore,
-                sim,
-                bm25: normalizedBm25,
-            };
         }
-        catch (err) {
-            console.error(`❌ Error processing embedding for file: ${result.path}`, err);
-            return null;
+        else {
+            // No embedding: fallback to inverse bm25-only
+            finalScore = 1 - ((result.bm25Score - bm25Min) / (bm25Max - bm25Min + 1e-5));
         }
-    })
-        .filter((r) => r !== null)
+        return {
+            path: result.path,
+            summary: result.summary,
+            score: finalScore,
+            sim,
+            bm25: result.bm25Score,
+        };
+    });
+    const sorted = scored
         .sort((a, b) => b.score - a.score)
         .slice(0, topK);
     console.log(`Returning top ${topK} results based on combined score`);
-    return scored;
+    return sorted;
 }
 function cosineSimilarity(a, b) {
     const dot = a.reduce((sum, ai, i) => sum + ai * b[i], 0);

package/dist/utils/normalizePath.js

@@ -0,0 +1,10 @@
+// src/utils/normalizePath.ts
+/**
+ * Normalizes a path string for loose, fuzzy matching:
+ * - Lowercases
+ * - Removes slashes and backslashes
+ * - Removes whitespace
+ */
+export function normalizePathForLooseMatch(p) {
+    return p.toLowerCase().replace(/[\\/]/g, '').replace(/\s+/g, '');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -17,7 +17,8 @@
     "refactor",
     "devtools",
     "local",
-    "typescript"
+    "typescript",
+    "llm"
   ],
   "scripts": {
     "build": "tsc",