scai 0.1.55 → 0.1.57

package/dist/config.js

@@ -1,79 +1,199 @@
 import fs from 'fs';
-import { CONFIG_PATH, SCAI_HOME, INDEX_DIR } from './constants.js'; // Correctly import INDEX_DIR from constants
-// Default configuration values
+import path from 'path';
+import { CONFIG_PATH, SCAI_HOME, SCAI_REPOS } from './constants.js';
+import { getDbForRepo } from './db/client.js';
+import { getRepoKeyForPath, normalizePath } from './utils/normalizePath.js';
+import chalk from 'chalk';
 const defaultConfig = {
     model: 'llama3',
     language: 'ts',
-    indexDir: INDEX_DIR, // Default index directory from constants
-    githubToken: '', // Add githubToken to default config
+    indexDir: '',
+    githubToken: '',
+    repos: {},
+    activeRepo: undefined,
 };
-// Function to ensure the configuration directory exists
 function ensureConfigDir() {
     if (!fs.existsSync(SCAI_HOME)) {
         fs.mkdirSync(SCAI_HOME, { recursive: true });
     }
 }
-// Function to read the configuration file
 function readConfig() {
     try {
         const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
         return { ...defaultConfig, ...JSON.parse(content) };
     }
     catch {
-        return defaultConfig; // Return default config if read fails
+        return defaultConfig;
     }
 }
-// Function to write the configuration to the config file
-function writeConfig(newConfig) {
+export function writeConfig(newCfg) {
     ensureConfigDir();
     const current = readConfig();
-    const merged = { ...current, ...newConfig };
+    const merged = {
+        ...current,
+        ...newCfg,
+        repos: {
+            ...current.repos,
+            ...(newCfg.repos || {}),
+        },
+    };
     fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2));
 }
 export const Config = {
-    // Get the current model from the config
     getModel() {
-        return readConfig().model;
+        const cfg = readConfig();
+        const repoCfg = cfg.repos?.[cfg.activeRepo ?? ''];
+        return repoCfg?.model || cfg.model;
     },
-    // Set a new model in the config
     setModel(model) {
-        writeConfig({ model });
-        console.log(`📦 Model set to: ${model}`);
+        const cfg = readConfig();
+        const active = cfg.activeRepo;
+        if (active) {
+            cfg.repos[active] = { ...cfg.repos[active], model };
+            writeConfig(cfg);
+            console.log(`📦 Model set to: ${model}`);
+        }
+        else {
+            writeConfig({ model });
+            console.log(`📦 Default model set to: ${model}`);
+        }
     },
-    // Get the current language from the config
     getLanguage() {
-        return readConfig().language;
+        const cfg = readConfig();
+        const repoCfg = cfg.repos?.[cfg.activeRepo ?? ''];
+        return repoCfg?.language || cfg.language;
     },
-    // Set a new language in the config
     setLanguage(language) {
-        writeConfig({ language });
-        console.log(`🗣️ Language set to: ${language}`);
+        const cfg = readConfig();
+        const active = cfg.activeRepo;
+        if (active) {
+            cfg.repos[active] = { ...cfg.repos[active], language };
+            writeConfig(cfg);
+            console.log(`🗣️ Language set to: ${language}`);
+        }
+        else {
+            writeConfig({ language });
+            console.log(`🗣️ Default language set to: ${language}`);
+        }
     },
-    // Get the index directory from the config
     getIndexDir() {
-        return readConfig().indexDir;
+        const config = readConfig();
+        const activeRepo = config.activeRepo;
+        if (activeRepo) {
+            const normalized = normalizePath(activeRepo);
+            return normalizePath(config.repos[normalized]?.indexDir ?? '');
+        }
+        return '';
+    },
+    async setIndexDir(indexDir) {
+        const absPath = path.resolve(indexDir); // Resolve the index directory to an absolute path
+        const repoKey = normalizePath(absPath); // Normalize path for the repo (get repo name, not full path)
+        // Ensure repoKey doesn't contain an absolute path, only the repo name or a relative path
+        const scaiRepoRoot = path.join(SCAI_REPOS, path.basename(repoKey)); // Use repo name as key to avoid double paths
+        // Set the active repo to the provided indexDir
+        const cfg = readConfig();
+        cfg.activeRepo = repoKey;
+        await writeConfig(cfg); // Persist the change in activeRepo
+        // Call setRepoIndexDir to update the repo's indexDir and other settings
+        await this.setRepoIndexDir(scaiRepoRoot, absPath); // Set the indexDir for the repo
+        // Ensure base folders exist
+        fs.mkdirSync(scaiRepoRoot, { recursive: true });
+        fs.mkdirSync(path.join(scaiRepoRoot, 'summaries'), { recursive: true });
+        fs.mkdirSync(path.join(scaiRepoRoot, 'metadata'), { recursive: true });
+        // Init DB if not exists
+        const dbPath = path.join(scaiRepoRoot, 'db.sqlite');
+        if (!fs.existsSync(dbPath)) {
+            console.log(`Database not found. Initializing DB at ${normalizePath(dbPath)}`);
+            getDbForRepo(); // Now DB creation works after config update
+        }
+        console.log(`✅ Index directory set to: ${normalizePath(absPath)}`);
+    },
+    /**
+     * Set both the scaiRepoRoot for the config and the indexDir (the actual repo root path)
+     * @param scaiRepoRoot
+     * @param indexDir
+     */
+    async setRepoIndexDir(scaiRepoRoot, indexDir) {
+        const normalizedRepoPath = normalizePath(scaiRepoRoot);
+        const normalizedIndexDir = normalizePath(indexDir);
+        const cfg = readConfig();
+        if (!cfg.repos[normalizedRepoPath]) {
+            cfg.repos[normalizedRepoPath] = {};
+        }
+        cfg.repos[normalizedRepoPath] = {
+            ...cfg.repos[normalizedRepoPath],
+            indexDir: normalizedIndexDir, // Ensure the indexDir is always normalized
+        };
+        await writeConfig(cfg); // Persist the config update
+        console.log(`✅ Repo index directory set for ${normalizedRepoPath} : ${normalizedIndexDir}`);
     },
-    // Set a new index directory in the config
-    setIndexDir(indexDir) {
-        writeConfig({ indexDir });
-        console.log(`📁 Index directory set to: ${indexDir}`);
+    setActiveRepo(repoKey) {
+        const cfg = readConfig();
+        cfg.activeRepo = repoKey;
+        writeConfig(cfg);
+        console.log(`✅ Active repo switched to: ${repoKey}`);
+    },
+    printAllRepos() {
+        const cfg = readConfig();
+        const keys = Object.keys(cfg.repos || {});
+        if (!keys.length) {
+            console.log('ℹ️ No repositories configured yet.');
+            return;
+        }
+        console.log('📁 Configured repositories:\n');
+        for (const key of keys) {
+            const r = cfg.repos[key];
+            const isActive = cfg.activeRepo === key;
+            // Use chalk to ensure proper coloring
+            const label = isActive
+                ? chalk.green(`✅ ${key} (active)`) // Active repo in green
+                : chalk.white(`  ${key}`); // Inactive repos in white
+            console.log(`- ${label}`);
+            console.log(`    ↳ indexDir: ${r.indexDir}`);
+        }
     },
-    // Get the GitHub token from the config
+    // Method to get GitHub token for the active repo
     getGitHubToken() {
-        return readConfig().githubToken || null;
+        const cfg = readConfig();
+        const active = cfg.activeRepo;
+        if (active) {
+            // Normalize the active repo path and fetch token from repos[activeRepo]
+            const normalizedActiveRepo = normalizePath(active);
+            return cfg.repos[normalizedActiveRepo]?.githubToken || null;
+        }
+        // If no activeRepo, fall back to the global githubToken field
+        return cfg.githubToken || null;
     },
-    // Set the GitHub token in the config
     setGitHubToken(token) {
-        writeConfig({ githubToken: token });
-        console.log("✅ GitHub token updated");
+        const cfg = readConfig();
+        const active = cfg.activeRepo;
+        if (active) {
+            const repoKey = getRepoKeyForPath(active, cfg) ?? normalizePath(active);
+            if (!cfg.repos[repoKey]) {
+                cfg.repos[repoKey] = {};
+            }
+            cfg.repos[repoKey] = {
+                ...cfg.repos[repoKey],
+                githubToken: token,
+            };
+        }
+        else {
+            cfg.githubToken = token;
+        }
+        writeConfig(cfg);
+        console.log('✅ GitHub token updated');
     },
-    // Show the current configuration
     show() {
         const cfg = readConfig();
+        const active = cfg.activeRepo;
         console.log(`🔧 Current configuration:`);
-        console.log(`   Model     : ${cfg.model}`);
-        console.log(`   Language  : ${cfg.language}`);
-        console.log(`   Index dir : ${cfg.indexDir}`);
-        console.log(`   GitHub Token: ${cfg.githubToken ? '*****' : 'Not Set'}`);
-    }
+        console.log(`   Active index dir: ${active || 'Not Set'}`);
+        const repoCfg = active ? cfg.repos?.[active] : {};
+        console.log(`   Model           : ${repoCfg?.model || cfg.model}`);
+        console.log(`   Language        : ${repoCfg?.language || cfg.language}`);
+        console.log(`   GitHub Token    : ${cfg.githubToken ? '*****' : 'Not Set'}`);
+    },
+    getRaw() {
+        return readConfig();
+    },
 };

package/dist/constants.js

@@ -7,10 +7,9 @@ import fs from 'fs';
  */
 export const SCAI_HOME = path.join(os.homedir(), '.scai');
 /**
- * Full path to the SQLite database used by SCAI:
- * ~/.scai/db.sqlite
+ * Repos dir for multi-repo setup
  */
-export const DB_PATH = path.join(SCAI_HOME, 'db.sqlite');
+export const SCAI_REPOS = path.join(SCAI_HOME, 'repos');
 /**
  * Path to the daemon process ID file (if running in background mode):
  * ~/.scai/daemon.pid
@@ -32,26 +31,24 @@ export const LOG_PATH = path.join(SCAI_HOME, 'daemon.log');
  */
 export const PROMPT_LOG_PATH = path.join(SCAI_HOME, 'prompt.log');
 /**
- * Get the active index directory.
+ * Get the active index directory based on the active repo.
  *
- * - If the user has configured an `indexDir`, use it.
- * - If not, default to the user’s home directory (`~`), not `.scai`.
+ * - If there is an active repository, return its `indexDir` from the config.
+ * - If no active repo is set, default to the user's home directory (`~`).
  */
 export function getIndexDir() {
     try {
         const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
-        return config.indexDir || os.homedir(); // 🏠 Default: ~
+        const activeRepo = config.activeRepo;
+        if (activeRepo && config.repos[activeRepo]) {
+            return config.repos[activeRepo].indexDir || os.homedir(); // Repo-specific indexDir or default to home
+        }
+        return os.homedir(); // Fallback to home if no active repo
     }
     catch (e) {
-        return os.homedir(); // 🏠 Fallback if config file is missing or invalid
+        return os.homedir(); // Fallback if config file is missing or invalid
     }
 }
-/**
- * On-demand index directory to scan for files.
- *
- * Used by indexing logic (`scai index`) to determine what folder to scan.
- */
-export const INDEX_DIR = getIndexDir();
 /**
  * Limit for number of related files included in model prompt.
  */
@@ -61,6 +58,6 @@ export const RELATED_FILES_LIMIT = 3;
  */
 export const CANDIDATE_LIMIT = 100;
 /**
- * Limit number of summery lines
+ * Limit number of summary lines
  */
 export const MAX_SUMMARY_LINES = 12;

package/dist/daemon/daemonBatch.js

@@ -1,13 +1,12 @@
 import { indexFunctionsForFile } from '../db/functionIndex.js';
-import { db } from '../db/client.js';
 import fs from 'fs/promises';
 import fsSync from 'fs';
 import { generateEmbedding } from '../lib/generateEmbedding.js';
-import { DB_PATH } from '../constants.js';
 import { log } from '../utils/log.js';
 import lockfile from 'proper-lockfile';
 import { summaryModule } from '../pipeline/modules/summaryModule.js';
 import { classifyFile } from '../fileRules/classifyFile.js';
+import { getDbForRepo, getDbPathForRepo } from '../db/client.js';
 import { markFileAsSkippedByPath, selectUnprocessedFiles, updateFileWithSummaryAndEmbedding, } from '../db/sqlTemplates.js';
 const MAX_FILES_PER_BATCH = 5;
 /**
@@ -16,7 +15,7 @@ const MAX_FILES_PER_BATCH = 5;
  */
 async function lockDb() {
     try {
-        return await lockfile.lock(DB_PATH);
+        return await lockfile.lock(getDbPathForRepo());
     }
     catch (err) {
         log('❌ Failed to acquire DB lock: ' + err);
@@ -34,6 +33,7 @@ async function lockDb() {
 export async function runDaemonBatch() {
     log('🟡 Starting daemon batch...');
     // Selects up to MAX_FILES_PER_BATCH files that haven't been processed yet
+    const db = getDbForRepo();
     const rows = db.prepare(selectUnprocessedFiles).all(MAX_FILES_PER_BATCH);
     if (rows.length === 0) {
         log('✅ No files left to process.');

package/dist/daemon/daemonWorker.js

@@ -1,4 +1,4 @@
-import { db } from '../db/client.js';
+import { getDbForRepo } from '../db/client.js';
 import { runDaemonBatch } from './daemonBatch.js';
 import { log } from '../utils/log.js';
 const SLEEP_MS = 2000;
@@ -7,6 +7,7 @@ const IDLE_SLEEP_MS = 5000;
 log('🛠️ daemonWorker.js loaded');
 async function isQueueEmpty() {
     try {
+        const db = getDbForRepo();
         const row = db.prepare(`
       SELECT COUNT(*) AS count
       FROM files

package/dist/db/client.js

@@ -1,9 +1,31 @@
-import Database from 'better-sqlite3';
 import fs from 'fs';
-import { DB_PATH, SCAI_HOME } from '../constants.js';
-// Ensure the directory exists
-fs.mkdirSync(SCAI_HOME, { recursive: true });
-// Open the database connection
-export const db = new Database(DB_PATH);
-// Set journal_mode to WAL for better concurrency
-db.pragma('journal_mode = WAL');
+import path from 'path';
+import { SCAI_HOME } from '../constants.js';
+import { Config } from '../config.js';
+import Database from 'better-sqlite3';
+/**
+ * Returns a per-repo SQLite database instance.
+ * Ensures the directory and file are created.
+ */
+export function getDbForRepo() {
+    const repoRoot = Config.getIndexDir();
+    if (!repoRoot) {
+        throw new Error('No index directory set. Please set an index directory first.');
+    }
+    fs.mkdirSync(SCAI_HOME, { recursive: true });
+    const dbPath = getDbPathForRepo();
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    const db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    return db;
+}
+export function getDbPathForRepo() {
+    const repoRoot = Config.getIndexDir();
+    if (!repoRoot) {
+        throw new Error('No index directory set. Please set an index directory first.');
+    }
+    // Use path.basename to get the repo name from the full path
+    const repoName = path.basename(repoRoot); // Get the last part of the path (the repo name)
+    const scaiRepoPath = path.join(SCAI_HOME, 'repos', repoName, 'db.sqlite');
+    return scaiRepoPath;
+}

package/dist/db/fileIndex.js

@@ -1,4 +1,3 @@
-import { db } from './client.js';
 import fs from 'fs';
 import path from 'path';
 import { generateEmbedding } from '../lib/generateEmbedding.js';
@@ -6,6 +5,7 @@ import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
 import * as sqlTemplates from './sqlTemplates.js';
 import { stringSimilarity } from 'string-similarity-js';
 import { CANDIDATE_LIMIT } from '../constants.js';
+import { getDbForRepo } from './client.js';
 /**
  * 📄 Index a single file into the database.
  *
@@ -20,6 +20,7 @@ export function indexFile(filePath, summary, type) {
     const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
     const fileName = path.basename(normalizedPath); // Extracting the filename
     // Insert into files table
+    const db = getDbForRepo();
     db.prepare(sqlTemplates.upsertFileTemplate).run({
         path: normalizedPath,
         filename: fileName, // Pass filename
@@ -51,6 +52,7 @@ export function indexFile(filePath, summary, type) {
  */
 export function queryFiles(safeQuery, limit = 10) {
     console.log(`Executing search query: ${safeQuery}`);
+    const db = getDbForRepo();
     const results = db.prepare(`
     SELECT f.id, f.path, f.filename, f.summary, f.type, f.last_modified, f.indexed_at
     FROM files f
@@ -81,6 +83,7 @@ export async function searchFiles(query, topK = 5) {
     }
     const safeQuery = sanitizeQueryForFts(query);
     console.log(`Executing search query in FTS5: ${safeQuery}`);
+    const db = getDbForRepo();
     const ftsResults = db.prepare(`
     SELECT fts.rowid AS id, f.path, f.filename, f.summary, f.type, bm25(files_fts) AS bm25Score, f.embedding
     FROM files f
@@ -158,6 +161,7 @@ export function getFunctionsForFiles(fileIds) {
     if (!fileIds.length)
         return {};
     const placeholders = fileIds.map(() => '?').join(',');
+    const db = getDbForRepo();
     const stmt = db.prepare(`
     SELECT f.file_id, f.name, f.start_line, f.end_line, f.content
     FROM functions f

package/dist/db/functionExtractors/extractFromJava.js

@@ -1,8 +1,9 @@
-import { db } from '../client.js';
+import { getDbForRepo } from '../client.js';
 import { markFileAsSkippedTemplate } from '../sqlTemplates.js';
 export async function extractFromJava(filePath, _content, fileId) {
     console.warn(`⛔️ Java extraction not implemented: ${filePath}`);
     // Mark the file as skipped with the relevant status update
+    const db = getDbForRepo();
     db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
     return false;
 }

package/dist/db/functionExtractors/extractFromJs.js

@@ -1,11 +1,11 @@
 import { parse } from 'acorn';
 import { ancestor as walkAncestor } from 'acorn-walk';
 import { generateEmbedding } from '../../lib/generateEmbedding.js';
-import { db } from '../client.js';
 import path from 'path';
 import { log } from '../../utils/log.js';
 import fs from 'fs';
 import { markFileAsSkippedTemplate, markFileAsExtractedTemplate, markFileAsFailedTemplate } from '../sqlTemplates.js';
+import { getDbForRepo } from '../client.js';
 function getFunctionName(node, parent, fileName) {
     if (node.id?.name)
         return node.id.name;
@@ -20,6 +20,7 @@ function getFunctionName(node, parent, fileName) {
     return `${fileName}:<anon>`;
 }
 export async function extractFromJS(filePath, content, fileId) {
+    const db = getDbForRepo();
     try {
         const code = fs.readFileSync(filePath, 'utf-8');
         console.log(`[Debug] Attempting to parse: ${filePath}`);

package/dist/db/functionExtractors/extractFromXML.js

@@ -1,8 +1,9 @@
-import { db } from '../client.js';
+import { getDbForRepo } from '../client.js';
 import { markFileAsSkippedTemplate } from '../sqlTemplates.js';
 export async function extractFromXML(filePath, _content, fileId) {
     console.warn(`⛔️ XML extraction not implemented: ${filePath}`);
     // Mark the file as skipped with the relevant status update
+    const db = getDbForRepo();
     db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
     return false;
 }

package/dist/db/functionExtractors/index.js

@@ -3,13 +3,14 @@ import { detectFileType } from '../../fileRules/detectFileType.js';
 import { extractFromJava } from './extractFromJava.js';
 import { extractFromJS } from './extractFromJs.js';
 import { extractFromXML } from './extractFromXML.js';
-import { db } from '../client.js';
+import { getDbForRepo } from '../client.js';
 import { markFileAsFailedTemplate, markFileAsSkippedByPath } from '../sqlTemplates.js';
 /**
  * Detects file type and delegates to the appropriate extractor.
  */
 export async function extractFunctionsFromFile(filePath, content, fileId) {
     const type = detectFileType(filePath).trim().toLowerCase();
+    const db = getDbForRepo();
     try {
         if (type === 'js' || type === 'ts' || type === 'javascript' || type === 'typescript') {
             log(`✅ Attempting to extract JS functions from ${filePath}`);

package/dist/db/schema.js

@@ -1,5 +1,6 @@
-import { db } from "./client.js";
+import { getDbForRepo } from "./client.js";
 export function initSchema() {
+    const db = getDbForRepo();
     db.exec(`
     -- Create the files table
     CREATE TABLE IF NOT EXISTS files (

package/dist/github/postComments.js

@@ -0,0 +1,69 @@
+import { Octokit } from '@octokit/rest';
+/**
+ * Parses the PR diff to determine the correct position for inline comments.
+ * The position is the "index" of the changed line in the diff.
+ * @param diff The diff content of the PR
+ * @param lineNumber The line number to convert to a position in the diff
+ */
+function getLinePositionFromDiff(diff, lineNumber) {
+    const lines = diff.split('\n');
+    let currentLine = 0;
+    // Iterate through the lines and determine the correct position for the lineNumber
+    for (let i = 0; i < lines.length; i++) {
+        // Only count the lines that are part of a diff chunk
+        if (lines[i].startsWith('+') || lines[i].startsWith('-')) {
+            currentLine++;
+            if (currentLine === lineNumber) {
+                return i; // Position is the index of the changed line in the diff
+            }
+        }
+    }
+    return null; // Return null if lineNumber is not found in the diff
+}
+/**
+ * Posts an inline review comment on a specific line of a PR.
+ *
+ * @param token GitHub personal access token
+ * @param owner Repository owner (e.g. 'my-org')
+ * @param repo Repository name (e.g. 'my-repo')
+ * @param prNumber Pull Request number
+ * @param fileName Path to the file in the PR (relative to repo root)
+ * @param lineNumber Line number to comment on in the file (not in the diff)
+ * @param comment Text of the comment
+ */
+export async function postReviewComment(token, owner, repo, prNumber, fileName, lineNumber, comment) {
+    const octokit = new Octokit({ auth: `token ${token}` });
+    // First, get PR details so we can retrieve the head commit SHA
+    const pr = await octokit.pulls.get({
+        owner,
+        repo,
+        pull_number: prNumber,
+    });
+    const commitId = pr.data.head.sha;
+    // Fetch the PR diff by getting the full diff URL from the PR
+    const diffUrl = pr.data.diff_url;
+    const diffRes = await fetch(diffUrl);
+    const diff = await diffRes.text();
+    // Get the position of the line in the diff
+    const position = getLinePositionFromDiff(diff, lineNumber);
+    if (position === null) {
+        console.error(`❌ Unable to find line ${lineNumber} in the diff for PR #${prNumber}.`);
+        return;
+    }
+    // Now, post the inline comment
+    try {
+        await octokit.pulls.createReviewComment({
+            owner,
+            repo,
+            pull_number: prNumber,
+            commit_id: commitId,
+            path: fileName,
+            body: comment,
+            position: position, // Use the position calculated from the diff
+        });
+        console.log(`✅ Inline comment posted to ${fileName} at diff position ${position}.`);
+    }
+    catch (err) {
+        console.error(`❌ Error posting inline comment: ${err.message}`);
+    }
+}