scai 0.1.103 → 0.1.105

package/dist/CHANGELOG.md

@@ -146,4 +146,15 @@ Type handling with the module pipeline
 
 • Fixed bug where entire block was returned as a single line for multi-line comments
 • Add multi-line comment handling with ~90% accuracy
-• Update CLI config file to use codellama:13b model and 4096 context length
+• Update CLI config file to use codellama:13b model and 4096 context length
+
+## 2025-08-30
+
+* Add new workflow management functionality to handle file writes.
+
+## 2025-08-31
+
+• Introduce Agent class with minimal implementation
+• Improve test-module's filepath handling and variable naming
+• Rename workflowManager.ts to agent/workflowManager.ts
+• Improved formatting of agent run summary output

package/dist/agent/agentManager.js

@@ -0,0 +1,28 @@
+// src/agent/agentManager.ts
+import chalk from "chalk";
+import fs from "fs/promises";
+import { getModuleByName } from "../pipeline/registry/moduleRegistry.js";
+import { handleAgentRun } from "./workflowManager.js";
+// Minimal agent: just collects modules and delegates to handleAgentRun
+export class Agent {
+    constructor(goals) {
+        // Trim goal names to avoid whitespace issues
+        this.goals = goals.map(g => g.trim());
+    }
+    async execute(filepath) {
+        console.log(chalk.cyan(`🤖 Agent starting on: ${filepath}`));
+        // Map goal names → module objects
+        const modules = this.goals.map(goal => {
+            const mod = getModuleByName(goal);
+            if (!mod)
+                throw new Error(`❌ Unknown module: ${goal}`);
+            return mod;
+        });
+        console.log(chalk.green("📋 Modules to run:"), modules.map(m => m.name).join(" → "));
+        // Read file content
+        const content = await fs.readFile(filepath, "utf-8");
+        // Delegate everything to handleAgentRun (like CLI commands do)
+        await handleAgentRun(filepath, modules);
+        console.log(chalk.green("✅ Agent finished!"));
+    }
+}

package/dist/agent/workflowManager.js

@@ -0,0 +1,89 @@
+// agentManager.ts
+import fs from 'fs/promises';
+import chalk from 'chalk';
+import { runModulePipeline } from '../pipeline/runModulePipeline.js';
+import { countTokens, splitCodeIntoChunks } from '../utils/splitCodeIntoChunk.js';
+import { normalizePath } from '../utils/contentUtils.js';
+export async function handleAgentRun(filepath, modules) {
+    try {
+        filepath = normalizePath(filepath);
+        let fileContent = await fs.readFile(filepath, 'utf-8');
+        // Immutable baseline for this file (stays until file changes)
+        const maxTokens = 1500;
+        const baseChunks = splitCodeIntoChunks(fileContent, maxTokens);
+        // Working chunks that flow through modules; stays index-aligned with baseChunks
+        let workingChunks = [...baseChunks];
+        for (const mod of modules) {
+            console.log(chalk.cyan(`\n⚙️ Running module: ${mod.name}`));
+            console.log(chalk.blue(`🧮 Tokens:`), chalk.yellow(countTokens(fileContent).toString()));
+            console.log(chalk.magenta(`📦 Chunks: ${workingChunks.length}`));
+            const processed = [];
+            let mode;
+            let newFilepath;
+            for (let i = 0; i < workingChunks.length; i++) {
+                const input = {
+                    originalContent: baseChunks[i], // immutable baseline for this file
+                    content: workingChunks[i], // current state for this slice
+                    filepath,
+                    chunkIndex: i,
+                    chunkCount: workingChunks.length,
+                };
+                const out = await runModulePipeline([mod], input);
+                if (!out.content?.trim()) {
+                    throw new Error(`⚠️ Empty result on chunk ${i + 1}`);
+                }
+                processed.push(out.content);
+                // Capture mode/path (should be consistent across chunks)
+                if (out.mode)
+                    mode = out.mode;
+                if (out.newFilepath)
+                    newFilepath = out.newFilepath;
+            }
+            const finalOutput = processed.join('\n\n');
+            // Apply output mode
+            switch (mode ?? 'overwrite') {
+                case 'overwrite':
+                    await fs.writeFile(filepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ Overwritten: ${filepath}`));
+                    // keep baseChunks (baseline stays the same), keep alignment: do NOT re-chunk
+                    workingChunks = processed;
+                    fileContent = finalOutput;
+                    break;
+                case 'append':
+                    await fs.appendFile(filepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ Appended: ${filepath}`));
+                    // appended file content diverges; keep alignment by using processed as new working
+                    workingChunks = processed;
+                    fileContent += finalOutput;
+                    break;
+                case 'newFile':
+                    if (!newFilepath)
+                        throw new Error(`newFile mode requires newFilepath`);
+                    await fs.writeFile(newFilepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ New file: ${newFilepath}`));
+                    // File context changes → reset baseline and working to the new file
+                    filepath = newFilepath;
+                    fileContent = finalOutput;
+                    const reset = splitCodeIntoChunks(fileContent, maxTokens);
+                    // new baseline for the new file (e.g., generated tests before cleaning)
+                    for (let i = 0; i < reset.length; i++)
+                        ; // (no-op; just clarity)
+                    // Replace both arrays to keep them in sync for subsequent modules
+                    workingChunks = reset;
+                    // Important: also reset baseChunks to this new file’s content so the next module
+                    // (e.g., cleaner) sees the *generated tests* as its originalContent baseline.
+                    baseChunks.length = 0;
+                    baseChunks.push(...reset);
+                    break;
+                default:
+                    console.log(chalk.yellow(`⚠️ Unknown mode; skipping write`));
+                    // still move pipeline forward with processed
+                    workingChunks = processed;
+                    fileContent = finalOutput;
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('❌ Error in agent run:'), err instanceof Error ? err.message : err);
+    }
+}

package/dist/commands/SwitchCmd.js

@@ -1,7 +1,7 @@
 // File: src/commands/switch.ts
 import readline from 'readline';
 import { Config, writeConfig } from '../config.js';
-import { getRepoKeyForPath } from '../utils/normalizePath.js';
+import { getRepoKeyForPath } from '../utils/contentUtils.js';
 import chalk from 'chalk';
 export function runSwitchCommand(inputPathOrKey) {
     const config = Config.getRaw();

package/dist/config.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { CONFIG_PATH, SCAI_HOME, SCAI_REPOS } from './constants.js';
 import { getDbForRepo } from './db/client.js';
-import { normalizePath } from './utils/normalizePath.js';
+import { normalizePath } from './utils/contentUtils.js';
 import chalk from 'chalk';
 import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {

package/dist/context.js

@@ -1,10 +1,12 @@
 // context.ts
-import { readConfig, writeConfig } from "./config.js";
-import { normalizePath } from "./utils/normalizePath.js";
+import { readConfig, writeConfig, Config } from "./config.js";
+import { normalizePath } from "./utils/contentUtils.js";
 import { getHashedRepoKey } from "./utils/repoKey.js";
 import { getDbForRepo, getDbPathForRepo } from "./db/client.js";
 import fs from "fs";
 import chalk from "chalk";
+import { generate } from "./lib/generate.js"; // 👈 use your existing generate wrapper
+import { startModelProcess } from "./utils/checkModel.js";
 export async function updateContext() {
     const cwd = normalizePath(process.cwd());
     const cfg = readConfig();
@@ -54,6 +56,17 @@ export async function updateContext() {
     else if (isNewRepo || activeRepoChanged) {
         console.log(chalk.green("✅ Database present"));
     }
+    // ✅ NEW: Ensure model is available
+    if (ok) {
+        const modelReady = await ensureModelReady();
+        if (modelReady) {
+            console.log(chalk.green("✅ Model ready"));
+        }
+        else {
+            console.log(chalk.red("❌ Model not available"));
+            ok = false;
+        }
+    }
     // Final context status
     if (ok) {
         console.log(chalk.bold.green("\n✅ Context OK\n"));
@@ -63,3 +76,15 @@ export async function updateContext() {
     }
     return ok;
 }
+async function ensureModelReady() {
+    try {
+        // simple "ping" prompt that costs almost nothing
+        const res = await generate({ content: "ping" }, Config.getModel());
+        return Boolean(res?.content);
+    }
+    catch {
+        console.log(chalk.yellow("⚡ Model not responding. Attempting to start..."));
+        await startModelProcess();
+        return false;
+    }
+}

package/dist/index.js

@@ -8,7 +8,6 @@ import { suggestCommitMessage } from "./commands/CommitSuggesterCmd.js";
 import { bootstrap } from './modelSetup.js';
 import { summarizeFile } from "./commands/SummaryCmd.js";
 import { handleStandaloneChangelogUpdate } from './commands/ChangeLogUpdateCmd.js';
-import { runModulePipelineFromCLI } from './commands/ModulePipelineCmd.js';
 import { runIndexCommand } from './commands/IndexCmd.js';
 import { resetDatabase } from './commands/ResetDbCmd.js';
 import { runFindCommand } from './commands/FindCmd.js';
@@ -26,13 +25,16 @@ import { runInteractiveSwitch } from "./commands/SwitchCmd.js";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 import { dirname, resolve } from "path";
-import { handleAgentRun } from './agentManager.js';
+import { handleAgentRun } from './agent/workflowManager.js';
 import { addCommentsModule } from './pipeline/modules/commentModule.js';
 import { generateTestsModule } from './pipeline/modules/generateTestsModule.js';
 import { preserveCodeModule } from './pipeline/modules/preserveCodeModule.js';
 import { runInteractiveDelete } from './commands/DeleteIndex.js';
 import { resolveTargetsToFiles } from './utils/resolveTargetsToFiles.js';
 import { updateContext } from './context.js';
+import { cleanGeneratedTestsModule } from './pipeline/modules/cleanGeneratedTestsModule.js';
+import { Agent } from './agent/agentManager.js';
+import { builtInModules } from './pipeline/registry/moduleRegistry.js';
 // 🎛️ CLI Setup
 const cmd = new Command('scai')
     .version(version)
@@ -46,6 +48,34 @@ cmd
     await bootstrap();
     console.log('✅ Model initialization completed!');
 });
+// 🔧 Group: Agent-related commands
+const agent = cmd
+    .command('agent')
+    .description(`Run an agent workflow. Available tools:\n` +
+    Object.keys(builtInModules).map(m => `  - ${m}`).join('\n') +
+    `\n\nExample usage:\n` +
+    `  $ scai agent run summary cleanup tests\n` +
+    `  This will run the agent with the goals: summary → cleanup → tests\n`);
+// Run workflow subcommand
+const runCmd = agent
+    .command('run <goals...>')
+    .description('Run an agent workflow with a list of goals')
+    .option('-f, --file <filepath>', 'File to process', 'example.txt')
+    .action(async (cmdGoals, cmd) => {
+    await withContext(async () => {
+        const goals = cmdGoals;
+        const file = cmd.file;
+        console.log('Agent will execute:', goals.join(' → '));
+        console.log('On file:', file);
+        const agentInstance = new Agent(goals);
+        await agentInstance.execute(file);
+    });
+});
+// Inject modules list into the --help output
+runCmd.on('--help', () => {
+    console.log('\nAvailable tools:');
+    Object.keys(builtInModules).forEach(m => console.log(`  - ${m}`));
+});
 // 🔧 Group: Git-related commands
 const git = cmd.command('git').description('Git utilities');
 git
@@ -149,12 +179,14 @@ gen
     });
 });
 gen
-    .command('testgen <file>')
-    .description('Generate tests for the given file')
-    .option('-a, --apply', 'Apply the output to the original file')
-    .action(async (file) => {
+    .command("test <targets...>")
+    .description("Generate tests for the given file(s) or folder(s)")
+    .action(async (targets, options) => {
     await withContext(async () => {
-        handleAgentRun(file, [generateTestsModule]);
+        const files = await resolveTargetsToFiles(targets);
+        for (const file of files) {
+            await handleAgentRun(file, [generateTestsModule, cleanGeneratedTestsModule]);
+        }
     });
 });
 // ⚙️ Group: Configuration settings
@@ -298,18 +330,6 @@ cmd
     const fullQuery = questionParts?.join(' ');
     await runAskCommand(fullQuery);
 }));
-cmd
-    .command('pipe')
-    .description('Run a module pipeline on a given file')
-    .argument('<file>', 'Target file')
-    .option('-m, --modules <modules>', 'Comma-separated list of modules to run (e.g., comments,cleanup,summary)')
-    .action((file, options) => {
-    if (!options.modules) {
-        console.error('❌ You must specify modules with -m or --modules');
-        process.exit(1);
-    }
-    runModulePipelineFromCLI(file, options);
-});
 cmd.addHelpText('after', `
 🚨 Alpha Features:
   - The "index", "daemon", "stop-daemon", "reset-db" commands are considered alpha features.

package/dist/pipeline/modules/cleanGeneratedTestsModule.js

@@ -0,0 +1,22 @@
+import { normalizeText, stripMarkdownFences, isCodeLike } from "../../utils/contentUtils.js";
+export const cleanGeneratedTestsModule = {
+    name: "cleanGeneratedTestsModule",
+    description: "Removes markdown fences, prose, and explanations from generated test output, leaving only code",
+    async run(input) {
+        const { content, filepath } = input;
+        // normalize + strip markdown
+        const normalized = normalizeText(content);
+        const stripped = stripMarkdownFences(normalized);
+        // filter non-code lines
+        const lines = stripped.split("\n");
+        // filter non-code lines, but keep blank ones
+        const codeLines = lines.filter(line => line.trim() === "" || isCodeLike(line));
+        const cleanedCode = codeLines.join("\n");
+        return {
+            originalContent: content,
+            content: cleanedCode, // cleaned code for pipeline
+            filepath, // original file path
+            mode: "overwrite", // indicates overwrite existing file
+        };
+    }
+};

package/dist/pipeline/modules/commentModule.js

@@ -59,6 +59,9 @@ ${input.content}
 `.trim();
         const response = await generate({ content: prompt }, model);
         const contentToReturn = (response.content && response.content !== 'NO UPDATE') ? response.content : input.content;
-        return { content: contentToReturn };
+        return {
+            content: contentToReturn,
+            mode: 'overwrite', // <-- declares that the original file should be overwritten
+        };
     },
 };

package/dist/pipeline/modules/generateTestsModule.js

@@ -1,4 +1,3 @@
-import fs from 'fs/promises';
 import path from 'path';
 import { generate } from '../../lib/generate.js';
 import { detectFileType } from '../../fileRules/detectFileType.js';
@@ -11,28 +10,50 @@ export const generateTestsModule = {
             throw new Error('Missing filepath in pipeline context');
         const model = Config.getModel();
         const lang = detectFileType(filepath);
+        const repoRoot = Config.getIndexDir();
+        // Compute relative import path (repo-relative, without extension)
+        const relativePath = path.relative(repoRoot, filepath);
+        const { dir, name, ext } = path.parse(relativePath);
+        const importPath = './' + path.join(dir, name).replace(/\\/g, '/');
+        // Where the test should be written (next to source file)
+        const absParsed = path.parse(filepath);
+        const testPath = path.join(absParsed.dir, `${absParsed.name}.test${ext}`);
         const prompt = `
-      You are a senior ${lang.toUpperCase()} engineer. Given the following class or module, generate a Jest test file.
+You are a senior ${lang.toUpperCase()} engineer. Generate a Jest test file for the module below.
 
-      Guidelines:
-      - Use the 'jest' test framework
-      - Cover only one public method: the most relevant or central function
-      - Include one edge case for that method
-      - Preserve and consider existing code comments
-      - Name the file <original>.test.${path.extname(filepath).slice(1)}
-      - Only return valid ${lang} code
+Requirements:
+- Use the 'jest' test framework.
+- Always include imports at the top:
+  import { describe, it, expect } from '@jest/globals';
+  import * as moduleUnderTest from '${importPath}';
+- Cover only one public method: the most relevant or central function.
+- Include one edge case for that method.
+- Preserve and consider existing code comments in the module.
+- Only output valid ${lang} code; do not include markdown fences or explanations.
+- Use this scaffold at minimum:
 
-      --- CODE START ---
-      ${content}
-      --- CODE END ---
-      `.trim();
+import { describe, it, expect } from '@jest/globals';
+import * as moduleUnderTest from '${importPath}';
+
+describe('moduleUnderTest', () => {
+  it('should ...', () => {
+    // test implementation
+  });
+});
+
+--- MODULE CODE ---
+${content}
+--- END MODULE CODE ---
+`.trim();
         const response = await generate({ content: prompt }, model);
         if (!response)
             throw new Error('⚠️ No test code returned from model');
-        const { dir, name } = path.parse(filepath);
-        const testPath = path.join(dir, `${name}.test.ts`);
-        await fs.writeFile(testPath, response.content, 'utf-8');
-        console.log(`✅ Test file saved to: ${testPath}`);
-        return { content, filepath }; // unchanged input
+        return {
+            originalContent: content,
+            content: response.content, // the test code
+            filepath, // original file path
+            newFilepath: testPath,
+            mode: "newFile" // ensure it gets written as a new file
+        };
     }
 };

package/dist/pipeline/modules/preserveCodeModule.js

@@ -144,6 +144,10 @@ export const preserveCodeModule = {
             const colored = type === "code" ? chalk.green(line) : chalk.yellow(line);
             console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
         });
-        return { content: fixedLines.join("\n"), filepath };
+        return {
+            content: fixedLines.join("\n"),
+            filepath,
+            mode: "overwrite"
+        };
     }
 };

package/dist/pipeline/registry/moduleRegistry.js

@@ -4,14 +4,18 @@ 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';
 // Add more as needed...
-const builtInModules = {
+export const builtInModules = {
     comments: addCommentsModule,
     cleanup: cleanupModule,
     summary: summaryModule,
     tests: generateTestsModule,
     suggest: commitSuggesterModule,
     changelog: changelogModule,
+    cleanTests: cleanGeneratedTestsModule,
+    cleanComments: preserveCodeModule
 };
 export function getModuleByName(name) {
     return builtInModules[name];

package/dist/utils/checkModel.js

@@ -0,0 +1,30 @@
+import { spawn } from "child_process";
+let modelProcess = null;
+async function isModelRunning() {
+    try {
+        const res = await fetch("http://localhost:11434/health"); // whatever endpoint your model exposes
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function startModelProcess() {
+    if (await isModelRunning()) {
+        console.log("✅ Model already running");
+        return;
+    }
+    console.log("🚀 Starting model process...");
+    modelProcess = spawn("ollama", ["serve"], {
+        stdio: "inherit",
+    });
+    // Poll until the model is ready
+    for (let i = 0; i < 30; i++) {
+        if (await isModelRunning()) {
+            console.log("✅ Model is now running");
+            return;
+        }
+        await new Promise((res) => setTimeout(res, 1000));
+    }
+    throw new Error("❌ Model failed to start in time");
+}

package/dist/utils/contentUtils.js

@@ -0,0 +1,49 @@
+import os from 'os';
+import path from "path";
+/**
+ * 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, '');
+}
+// Helper to normalize and resolve paths to a consistent format (forward slashes)
+export function normalizePath(p) {
+    if (p.startsWith('~')) {
+        p = path.join(os.homedir(), p.slice(1));
+    }
+    return path.resolve(p).replace(/\\/g, '/');
+}
+export function getRepoKeyForPath(pathToMatch, config) {
+    const norm = normalizePath(pathToMatch);
+    return Object.entries(config.repos).find(([, val]) => normalizePath(val.indexDir) === norm)?.[0] || null;
+}
+export function normalizeText(txt) {
+    return txt.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function stripMarkdownFences(txt) {
+    return txt
+        .replace(/```[\w-]*\s*/g, "") // ``` or ```java
+        .replace(/```/g, ""); // closing ```
+}
+// Very naive classifier: decide if a line is "code-like"
+export function isCodeLike(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    // obvious markdown / prose markers
+    if (/^(This|Here is|Note)\b/.test(trimmed))
+        return false;
+    if (/^\d+\./.test(trimmed))
+        return false; // bullet list
+    if (/^[-*] /.test(trimmed))
+        return false; // list
+    // allow imports, class, functions, braces, annotations, etc.
+    if (/^(import|export|public|private|protected|class|function|@Test|@Before)/.test(trimmed))
+        return true;
+    if (/[;{}()=]/.test(trimmed))
+        return true;
+    return false;
+}

package/dist/utils/repoKey.js

@@ -1,6 +1,6 @@
 import crypto from 'crypto';
 import path from 'path';
-import { normalizePath } from './normalizePath.js';
+import { normalizePath } from './contentUtils.js';
 /**
  * Generate a stable unique key for a repo path.
  * Uses the basename plus a short hash of the full path.

package/package.json

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

package/dist/agentManager.js

@@ -1,47 +0,0 @@
-import fs from 'fs/promises';
-import chalk from 'chalk';
-import { runModulePipeline } from './pipeline/runModulePipeline.js';
-import { normalizePath } from './utils/normalizePath.js';
-import { readConfig } from './config.js';
-import { countTokens, splitCodeIntoChunks } from './utils/splitCodeIntoChunk.js';
-export async function handleAgentRun(filepath, modules) {
-    try {
-        filepath = normalizePath(filepath);
-        const content = await fs.readFile(filepath, 'utf-8');
-        const totalTokens = countTokens(content);
-        console.log(chalk.blue(`🧮 Total tokens in file:`), chalk.yellow(totalTokens.toString()));
-        const config = readConfig();
-        const maxTokens = 1500;
-        const chunks = splitCodeIntoChunks(content, maxTokens);
-        console.log(chalk.magenta(`📦 Split into ${chunks.length} chunks`));
-        const processedChunks = [];
-        for (const [i, chunk] of chunks.entries()) {
-            const chunkTokens = countTokens(chunk);
-            if (i === 0) {
-                console.log(chalk.cyan(`🔍 Processing ${chunks.length} chunks of file:`), chalk.white(filepath));
-            }
-            console.log(chalk.gray(`   - Chunk ${i + 1} tokens:`), chalk.yellow(chunkTokens.toString()));
-            const chunkInput = {
-                originalContent: chunk,
-                content: chunk,
-                filepath,
-                chunkIndex: i,
-                chunkCount: chunks.length,
-            };
-            const response = await runModulePipeline(modules, chunkInput);
-            if (!response.content.trim()) {
-                throw new Error(`⚠️ Model returned empty result on chunk ${i + 1}`);
-            }
-            processedChunks.push(response.content);
-            //console.log(chalk.green(`✅ Finished chunk ${i + 1}/${chunks.length}`));
-        }
-        // Join all chunk outputs into one string
-        const finalOutput = processedChunks.join('\n\n');
-        // Overwrite original file here:
-        await fs.writeFile(filepath, finalOutput, 'utf-8');
-        console.log(chalk.green(`✅ Original file overwritten: ${filepath}`));
-    }
-    catch (err) {
-        console.error(chalk.red('❌ Error in agent run:'), err instanceof Error ? err.message : err);
-    }
-}

package/dist/utils/normalizePath.js

@@ -1,23 +0,0 @@
-// src/utils/normalizePath.ts
-import os from 'os';
-import path from "path";
-/**
- * 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, '');
-}
-// Helper to normalize and resolve paths to a consistent format (forward slashes)
-export function normalizePath(p) {
-    if (p.startsWith('~')) {
-        p = path.join(os.homedir(), p.slice(1));
-    }
-    return path.resolve(p).replace(/\\/g, '/');
-}
-export function getRepoKeyForPath(pathToMatch, config) {
-    const norm = normalizePath(pathToMatch);
-    return Object.entries(config.repos).find(([, val]) => normalizePath(val.indexDir) === norm)?.[0] || null;
-}