scai 0.1.26 → 0.1.28

package/dist/commands/{QueryCmd.js → FindCmd.js}

@@ -1,20 +1,21 @@
 import { queryFiles } from '../db/fileIndex.js';
+import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
 import path from 'path';
-export async function runQueryCommand(query) {
+export async function runFindCommand(query) {
     if (!query) {
-        console.error('❌ Please provide a search query.\n👉 Usage: scai query "keyword"');
+        console.error('❌ Please provide a search query.\n👉 Usage: scai find "keyword"');
         return;
     }
-    console.log(`🔍 Searching for: "${query}"\n`);
-    const results = queryFiles(query);
+    console.log(`\n🔍 Searching for: "${query}"\n`);
+    const sanitizedQuery = sanitizeQueryForFts(query);
+    const results = queryFiles(sanitizedQuery);
     if (results.length === 0) {
         console.log('⚠️ No matching files found.');
         return;
     }
+    console.log(`✅ Found ${results.length} result(s).`);
+    console.log();
     results.forEach((result, index) => {
         console.log(`📄 [${index + 1}] ${path.relative(process.cwd(), result.path)}`);
-        console.log(`   📝 ${result.summary}`);
-        console.log();
     });
-    console.log(`✅ Found ${results.length} result(s).`);
 }

package/dist/commands/SummaryCmd.js

@@ -1,23 +1,48 @@
 import fs from 'fs/promises';
+import path from 'path';
 import readline from 'readline';
-import { summaryModule } from '../pipeline/modules/summaryModule.js'; // Import summaryModule
-import { summarizeCode } from '../utils/summarizer.js'; // Import summarizeCode
+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 filePathResolved;
+    // 📁 Resolve path like `scai find`
     if (filepath) {
+        const sanitizedQuery = sanitizeQueryForFts(filepath);
+        const matches = queryFiles(sanitizedQuery);
+        if (matches.length > 0) {
+            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;
+        }
+    }
+    // 📄 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 {
-            content = await fs.readFile(filepath, 'utf-8');
+            content = await fs.readFile(filePathResolved, 'utf-8');
         }
         catch (err) {
-            console.error(`❌ Could not read or summarize ${filepath}:`, err.message);
+            console.error(`❌ Could not read file: ${filePathResolved}\n${err.message}`);
             return;
         }
     }
-    else if (process.stdin.isTTY) {
-        console.error('❌ No file provided and no piped input.\n👉 Usage: scai summ <file> or cat file | scai summ');
-        return;
-    }
-    else {
+    else if (!process.stdin.isTTY) {
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
@@ -27,18 +52,33 @@ export async function summarizeFile(filepath) {
             content += line + '\n';
         }
     }
+    else {
+        console.error('❌ No file provided and no piped input.\n👉 Usage: scai summ <file> or cat file | scai summ');
+        return;
+    }
+    // 🧠 Generate summary and save
     if (content.trim()) {
-        // Call the summary module to get the raw summary
+        console.log('🧪 Generating summary...\n');
         const response = await summaryModule.run({ content, filepath });
-        // Pass the summary text to the utility function for formatting
         if (!response.summary) {
-            console.warn("No summary available.");
+            console.warn('⚠️ No summary generated.');
             return;
         }
-        const formattedSummary = summarizeCode(response.summary);
-        console.log(formattedSummary);
+        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 code provided to summarize.');
+        console.error('❌ No content provided to summarize.');
     }
 }

package/dist/db/fileIndex.js

@@ -29,15 +29,7 @@ export function indexFile(filePath, summary, type) {
 /**
  * Perform a raw keyword-based full-text search using the FTS5 index.
  */
-export function queryFiles(query, limit = 10) {
-    const safeQuery = query
-        .trim()
-        .split(/\s+/)
-        .map(token => {
-        token = token.replace(/[?*\\"]/g, '').replace(/'/g, "''");
-        return token.includes(' ') ? `"${token}"` : `${token}*`;
-    })
-        .join(' OR ');
+export function queryFiles(safeQuery, limit = 10) {
     console.log(`Executing search query: ${safeQuery}`);
     const results = db.prepare(`
     SELECT f.id, f.path, f.summary, f.type, f.last_modified, f.indexed_at
@@ -46,10 +38,6 @@ export function queryFiles(query, limit = 10) {
     WHERE fts.files_fts MATCH ?
     LIMIT ?
   `).all(safeQuery, limit);
-    console.log(`Search returned ${results.length} results.`);
-    results.forEach(result => {
-        console.log(`📄 Found in FTS search: ${result.path}`);
-    });
     return results;
 }
 /**
@@ -65,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 => {
@@ -84,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/index.js

@@ -5,6 +5,7 @@ import { Config } from './config.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
+// 🧠 Commands
 import { suggestCommitMessage } from "./commands/CommitSuggesterCmd.js";
 import { handleRefactor } from "./commands/RefactorCmd.js";
 import { generateTests } from "./commands/TestGenCmd.js";
@@ -14,7 +15,7 @@ import { handleChangelogUpdate } from './commands/ChangeLogUpdateCmd.js';
 import { runModulePipelineFromCLI } from './commands/ModulePipelineCmd.js';
 import { runIndexCommand } from './commands/IndexCmd.js';
 import { resetDatabase } from './commands/ResetDbCmd.js';
-import { runQueryCommand } from './commands/QueryCmd.js';
+import { runFindCommand } from './commands/FindCmd.js';
 import { startDaemon } from './commands/DaemonCmd.js';
 import { runStopDaemonCommand } from "./commands/StopDaemonCmd.js";
 import { runAskCommand } from './commands/AskCmd.js';
@@ -113,9 +114,9 @@ cmd
 });
 // 🧠 Query and assistant
 cmd
-    .command('query <query>')
+    .command('find <query>')
     .description('Search indexed files by keyword')
-    .action(runQueryCommand);
+    .action(runFindCommand);
 cmd
     .command('ask [question...]') // <- the ... makes it variadic
     .description('Ask a question based on indexed files')

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/dist/utils/sanitizeQuery.js

@@ -1,16 +1,19 @@
 // src/utils/sanitizeQuery.ts
 import { STOP_WORDS } from '../config/StopWords.js';
 export function sanitizeQueryForFts(input) {
+    input = input.trim().toLowerCase();
+    // If it's a single filename-like string (includes dots or slashes), quote it
+    if (/^[\w\-./]+$/.test(input) && !/\s/.test(input)) {
+        // Escape quotes and wrap with double-quotes for FTS safety
+        return `"${input.replace(/"/g, '""')}"*`;
+    }
+    // Otherwise, treat it as a natural language prompt
     const tokens = input
-        .trim()
         .split(/\s+/)
         .map(token => token.toLowerCase())
         .filter(token => token.length > 2 &&
         !STOP_WORDS.has(token) &&
         /^[a-z0-9]+$/.test(token))
         .map(token => token.replace(/[?*\\"]/g, '').replace(/'/g, "''") + '*');
-    // 👇 Prevent FTS syntax errors by returning a catch-all query
-    if (tokens.length === 0)
-        return '*';
-    return tokens.join(' OR ');
+    return tokens.length > 0 ? tokens.join(' OR ') : '*';
 }

package/dist/utils/textWrapper.js

@@ -3,6 +3,14 @@ export function wrapText(text, maxWidth) {
     let wrappedText = '';
     let currentLine = '';
     words.forEach(word => {
+        // If the word is longer than the maxWidth, break it up into multiple lines
+        if (word.length > maxWidth) {
+            // Break the word into smaller chunks
+            while (word.length > maxWidth) {
+                wrappedText += word.slice(0, maxWidth) + '\n';
+                word = word.slice(maxWidth);
+            }
+        }
         // Check if adding the word would exceed the max width
         if ((currentLine + word).length > maxWidth) {
             wrappedText += currentLine + '\n'; // Add the current line and start a new one
@@ -13,6 +21,6 @@ export function wrapText(text, maxWidth) {
         }
     });
     // Append the last line if any
-    wrappedText += currentLine;
+    wrappedText += currentLine.trim(); // trim() to remove the extra space at the end
     return wrappedText;
 }

package/package.json

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

package/dist/commands/EnvCmd.js

@@ -1,10 +0,0 @@
-export function checkEnv() {
-    const requiredVars = ["DB_HOST", "API_KEY"];
-    const missing = requiredVars.filter((v) => !process.env[v]);
-    if (missing.length) {
-        console.warn("❌ Missing env vars:", missing.join(", "));
-    }
-    else {
-        console.log("✅ All env vars are set");
-    }
-}