quackstack 1.0.4 → 1.0.6

package/dist/cli.cjs

@@ -7,33 +7,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const chalk_animation_1 = __importDefault(require("chalk-animation"));
 const repl_js_1 = require("./repl.js");
-const cursor_context_js_1 = require("./lib/cursor-context.js");
+const context_generator_js_1 = require("./lib/context-generator.js");
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
 const PROJECT_NAME = path_1.default.basename(process.cwd());
 program
     .name("quackstack")
     .description("Your cracked unpaid intern for all things codebase!")
-    .version("1.0.0")
+    .version("1.0.4")
     .option("-r, --reindex", "Force reindex the codebase")
-    .option("-c, --cursor", "Generate .cursorrules file for Cursor AI")
-    .option("-w, --watch", "Watch mode: auto-update Cursor context on file changes")
+    .option("-c, --context", "Generate context files for ALL AI coding tools (Cursor, Windsurf, Cline, Continue, Aider)")
+    .option("-d, --docs", "Generate CODEBASE.md - universal documentation for any IDE/editor")
+    .option("--cursor", "[DEPRECATED] Use --context instead. Generates .cursorrules only")
+    .option("-w, --watch", "Watch mode: auto-update context files on file changes")
     .action(async (options) => {
     const title = chalk_animation_1.default.rainbow("Welcome to QuackStack! 🐥\n");
     await new Promise(res => setTimeout(res, 1500));
     title.stop();
+    if (options.context) {
+        await (0, context_generator_js_1.generateContextFiles)(PROJECT_NAME);
+        await (0, context_generator_js_1.updateGlobalContext)(PROJECT_NAME);
+        process.exit(0);
+    }
     if (options.cursor) {
-        console.log("🔍 Generating Cursor context...\n");
-        await (0, cursor_context_js_1.generateCursorContext)(PROJECT_NAME);
-        await (0, cursor_context_js_1.updateCursorGlobalContext)(PROJECT_NAME);
-        console.log("\n✅ Cursor integration complete!");
-        console.log("💡 Cursor will now have context about your codebase");
+        console.log("⚠️  --cursor is deprecated. Use --context to support all AI tools.\n");
+        console.log("🔍 Generating context for AI assistants...\n");
+        await (0, context_generator_js_1.generateContextFiles)(PROJECT_NAME);
+        await (0, context_generator_js_1.updateGlobalContext)(PROJECT_NAME);
+        console.log("\n✅ Context generation complete!");
+        console.log("💡 Your AI coding assistant will now have codebase context");
         process.exit(0);
     }
     if (options.watch) {
-        console.log("👀 Starting watch mode for Cursor context...\n");
-        await (0, cursor_context_js_1.generateCursorContext)(PROJECT_NAME);
-        (0, cursor_context_js_1.watchAndUpdateCursor)(PROJECT_NAME);
+        console.log("👀 Starting watch mode...\n");
+        await (0, context_generator_js_1.generateContextFiles)(PROJECT_NAME);
+        (0, context_generator_js_1.watchAndUpdateContext)(PROJECT_NAME);
         await new Promise(() => { });
     }
     await (0, repl_js_1.startREPL)(options.reindex);

package/dist/commands/ingest.js

@@ -2,45 +2,55 @@ import fs from "fs";
 import path from "path";
 import { scanDir } from "../lib/scanner.js";
 import { chunkCode } from "../lib/chunker.js";
-import { aiClient } from "../lib/ai-provider.js";
 import { saveToDB } from "../lib/database.js";
+import { localEmbeddings } from "../lib/local-embeddings.js";
 export async function ingest(rootDir, projectName, silent = false) {
     if (!silent)
         console.log("Starting ingestion...");
     const files = await scanDir(rootDir);
     if (!silent)
         console.log(`Found ${files.length} files to process`);
+    const allChunks = [];
+    for (const filePath of files) {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const chunks = chunkCode(content, filePath);
+            chunks.forEach(chunk => {
+                allChunks.push({ content: chunk.content, filePath, chunk });
+            });
+        }
+        catch (error) {
+            console.error(`Error reading ${filePath}:`, error);
+        }
+    }
+    if (!silent)
+        console.log(`Computing embeddings for ${allChunks.length} chunks...`);
+    const allContent = allChunks.map(c => c.content);
+    localEmbeddings.addDocuments(allContent);
+    if (!silent)
+        console.log(`Saving to database...`);
+    const BATCH_SIZE = 50;
     let processedCount = 0;
-    const BATCH_SIZE = 10;
-    for (let i = 0; i < files.length; i += BATCH_SIZE) {
-        const batch = files.slice(i, i + BATCH_SIZE);
-        await Promise.all(batch.map(async (filePath) => {
-            try {
-                const content = fs.readFileSync(filePath, "utf-8");
-                const chunks = chunkCode(content, filePath);
-                for (const chunk of chunks) {
-                    const embedding = await aiClient.getEmbeddings(chunk.content);
-                    await saveToDB({
-                        content: chunk.content,
-                        embedding,
-                        filePath,
-                        projectName,
-                        language: path.extname(filePath),
-                        functionName: chunk.functionName,
-                        lineStart: chunk.lineStart,
-                        lineEnd: chunk.lineEnd,
-                    });
-                }
-                processedCount++;
-                if (!silent && processedCount % 10 === 0) {
-                    console.log(`Processed ${processedCount}/${files.length} files...`);
-                }
-            }
-            catch (error) {
-                console.error(`Error processing ${filePath}:`, error);
-            }
+    for (let i = 0; i < allChunks.length; i += BATCH_SIZE) {
+        const batch = allChunks.slice(i, i + BATCH_SIZE);
+        await Promise.all(batch.map(async ({ content, filePath, chunk }) => {
+            const embedding = localEmbeddings.getVector(content);
+            await saveToDB({
+                content,
+                embedding,
+                filePath,
+                projectName,
+                language: path.extname(filePath),
+                functionName: chunk.functionName,
+                lineStart: chunk.lineStart,
+                lineEnd: chunk.lineEnd,
+            });
         }));
+        processedCount += batch.length;
+        if (!silent && processedCount % 100 === 0) {
+            console.log(`Saved ${processedCount}/${allChunks.length} chunks...`);
+        }
     }
     if (!silent)
-        console.log(`Done! Processed ${processedCount} files.`);
+        console.log(`Done! Processed ${processedCount} chunks from ${files.length} files.`);
 }

package/dist/commands/search.js

@@ -1,39 +1,33 @@
 #!/usr/bin/env node
-import { aiClient } from "../lib/ai-provider.js";
 import { client } from "../lib/database.js";
-function cosineSim(a, b) {
-    let dot = 0, normA = 0, normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
-}
+import { localEmbeddings } from "../lib/local-embeddings.js";
+import { aiClient } from "../lib/ai-provider.js";
 export async function search(query, projectName) {
-    const queryEmbedding = await aiClient.getEmbeddings(query);
     const snippets = await client.codeSnippet.findMany({
         where: { projectName },
     });
-    const scored = snippets.map(snippet => ({
+    const allContent = snippets.map(s => s.content);
+    localEmbeddings.addDocuments(allContent);
+    const queryVector = localEmbeddings.getVector(query);
+    const ranked = snippets
+        .map(snippet => ({
         id: snippet.id,
         content: snippet.content,
         filePath: snippet.filePath,
         functionName: snippet.functionName,
-        score: cosineSim(queryEmbedding, snippet.embedding),
-    }));
-    scored.sort((a, b) => b.score - a.score);
+        score: localEmbeddings.cosineSimilarity(queryVector, snippet.embedding),
+    }))
+        .sort((a, b) => b.score - a.score);
     const seenFiles = new Set();
-    const ranked = scored.filter(item => {
-        if (seenFiles.has(item.filePath)) {
+    const uniqueResults = ranked.filter(item => {
+        if (seenFiles.has(item.filePath))
             return false;
-        }
         seenFiles.add(item.filePath);
         return true;
     }).slice(0, 5);
-    const context = ranked
+    const context = uniqueResults
         .map((r, i) => `[${i + 1}] ${r.filePath}${r.functionName ? ` (${r.functionName})` : ""}\n${r.content}`)
         .join("\n\n---\n\n");
     const answer = await aiClient.generateAnswer(query, context);
-    return { answer, sources: ranked };
+    return { answer, sources: uniqueResults };
 }

package/dist/lib/ai-provider.js

@@ -11,126 +11,160 @@ export class AIClient {
     deepseek;
     mistral;
     constructor() {
+        const config = this.detectProvider();
+        this.provider = config.provider;
+        this.initializeClient(config);
+    }
+    detectProvider() {
         if (process.env.QUACKSTACK_OPENAI_KEY) {
-            this.provider = "openai";
-            this.openai = new OpenAI({
-                apiKey: process.env.QUACKSTACK_OPENAI_KEY
-            });
+            return {
+                provider: "openai",
+                apiKey: process.env.QUACKSTACK_OPENAI_KEY,
+            };
         }
-        else if (process.env.QUACKSTACK_ANTHROPIC_KEY) {
-            this.provider = "anthropic";
-            this.anthropic = new Anthropic({
-                apiKey: process.env.QUACKSTACK_ANTHROPIC_KEY
-            });
+        if (process.env.QUACKSTACK_ANTHROPIC_KEY) {
+            return {
+                provider: "anthropic",
+                apiKey: process.env.QUACKSTACK_ANTHROPIC_KEY,
+            };
         }
-        else if (process.env.QUACKSTACK_GEMINI_KEY) {
-            this.provider = "gemini";
-            this.gemini = new GoogleGenerativeAI(process.env.QUACKSTACK_GEMINI_KEY);
+        if (process.env.QUACKSTACK_GEMINI_KEY) {
+            return {
+                provider: "gemini",
+                apiKey: process.env.QUACKSTACK_GEMINI_KEY,
+            };
         }
-        else if (process.env.QUACKSTACK_DEEPSEEK_KEY) {
-            this.provider = "deepseek";
-            this.deepseek = new OpenAI({
+        if (process.env.QUACKSTACK_DEEPSEEK_KEY) {
+            return {
+                provider: "deepseek",
                 apiKey: process.env.QUACKSTACK_DEEPSEEK_KEY,
-                baseURL: "https://api.deepseek.com/v1"
-            });
+            };
         }
-        else if (process.env.QUACKSTACK_MISTRAL_KEY) {
-            this.provider = "mistral";
-            this.mistral = new OpenAI({
+        if (process.env.QUACKSTACK_MISTRAL_KEY) {
+            return {
+                provider: "mistral",
                 apiKey: process.env.QUACKSTACK_MISTRAL_KEY,
-                baseURL: "https://api.mistral.ai/v1"
-            });
-        }
-        else {
-            throw new Error("No AI API key found. Please set one of:\n" +
-                "  QUACKSTACK_OPENAI_KEY (GPT-4)\n" +
-                "  QUACKSTACK_ANTHROPIC_KEY (Claude)\n" +
-                "  QUACKSTACK_GEMINI_KEY (Gemini)\n" +
-                "  QUACKSTACK_DEEPSEEK_KEY (DeepSeek)\n" +
-                "  QUACKSTACK_MISTRAL_KEY (Mistral)");
+            };
         }
+        throw new Error("No AI API key found. Please set one of:\n" +
+            "  QUACKSTACK_OPENAI_KEY      - OpenAI GPT-4\n" +
+            "  QUACKSTACK_ANTHROPIC_KEY   - Anthropic Claude\n" +
+            "  QUACKSTACK_GEMINI_KEY      - Google Gemini (free tier available)\n" +
+            "  QUACKSTACK_DEEPSEEK_KEY    - DeepSeek (cheapest option)\n" +
+            "  QUACKSTACK_MISTRAL_KEY     - Mistral AI\n\n" +
+            "Get your API key from the respective provider's website.");
     }
-    async getEmbeddings(text) {
-        const embeddingKey = process.env.QUACKSTACK_OPENAI_KEY ||
-            process.env.QUACKSTACK_EMBEDDING_KEY;
-        if (embeddingKey) {
-            const client = new OpenAI({ apiKey: embeddingKey });
-            const response = await client.embeddings.create({
-                model: "text-embedding-3-large",
-                input: text
-            });
-            return response.data[0].embedding;
-        }
-        if (process.env.QUACKSTACK_DEEPSEEK_KEY) {
-            const client = new OpenAI({
-                apiKey: process.env.QUACKSTACK_DEEPSEEK_KEY,
-                baseURL: "https://api.deepseek.com/v1"
-            });
-            const response = await client.embeddings.create({
-                model: "deepseek-chat",
-                input: text
-            });
-            return response.data[0].embedding;
+    initializeClient(config) {
+        switch (config.provider) {
+            case "openai":
+                this.openai = new OpenAI({ apiKey: config.apiKey });
+                break;
+            case "anthropic":
+                this.anthropic = new Anthropic({ apiKey: config.apiKey });
+                break;
+            case "gemini":
+                this.gemini = new GoogleGenerativeAI(config.apiKey);
+                break;
+            case "deepseek":
+                this.deepseek = new OpenAI({
+                    apiKey: config.apiKey,
+                    baseURL: "https://api.deepseek.com/v1",
+                });
+                break;
+            case "mistral":
+                this.mistral = new OpenAI({
+                    apiKey: config.apiKey,
+                    baseURL: "https://api.mistral.ai/v1",
+                });
+                break;
         }
-        throw new Error("Embeddings require an API key. Set one of:\n" +
-            "  QUACKSTACK_OPENAI_KEY\n" +
-            "  QUACKSTACK_DEEPSEEK_KEY\n" +
-            "  QUACKSTACK_EMBEDDING_KEY");
     }
     async generateAnswer(query, context) {
-        const systemPrompt = "You are a helpful coding assistant. Answer questions about the codebase using the provided code snippets. Be concise and reference specific files when relevant.";
+        const systemPrompt = "You are a helpful coding assistant. Answer questions about the codebase using the provided code snippets. " +
+            "Be concise and reference specific files when relevant. Format your responses in markdown for clarity.";
         const userPrompt = `Code context:\n\n${context}\n\nQuestion: ${query}`;
-        if (this.provider === "openai" && this.openai) {
-            const response = await this.openai.chat.completions.create({
-                model: "gpt-4o-mini",
-                messages: [
-                    { role: "system", content: systemPrompt },
-                    { role: "user", content: userPrompt }
-                ],
-                temperature: 0.3,
-            });
-            return response.choices[0].message.content || "No response generated.";
-        }
-        if (this.provider === "anthropic" && this.anthropic) {
-            const response = await this.anthropic.messages.create({
-                model: "claude-3-5-sonnet-20241022",
-                max_tokens: 2048,
-                system: systemPrompt,
-                messages: [
-                    { role: "user", content: userPrompt }
-                ]
-            });
-            const textContent = response.content.find(c => c.type === "text");
-            return textContent && textContent.type === "text" ? textContent.text : "No response generated.";
-        }
-        if (this.provider === "gemini" && this.gemini) {
-            const model = this.gemini.getGenerativeModel({ model: "gemini-1.5-flash" });
-            const result = await model.generateContent(`${systemPrompt}\n\n${userPrompt}`);
-            return result.response.text();
+        try {
+            switch (this.provider) {
+                case "openai":
+                    return await this.generateOpenAI(systemPrompt, userPrompt);
+                case "anthropic":
+                    return await this.generateAnthropic(systemPrompt, userPrompt);
+                case "gemini":
+                    return await this.generateGemini(systemPrompt, userPrompt);
+                case "deepseek":
+                    return await this.generateDeepSeek(systemPrompt, userPrompt);
+                case "mistral":
+                    return await this.generateMistral(systemPrompt, userPrompt);
+                default:
+                    throw new Error(`Unsupported provider: ${this.provider}`);
+            }
         }
-        if (this.provider === "deepseek" && this.deepseek) {
-            const response = await this.deepseek.chat.completions.create({
-                model: "deepseek-chat",
-                messages: [
-                    { role: "system", content: systemPrompt },
-                    { role: "user", content: userPrompt }
-                ],
-                temperature: 0.3,
-            });
-            return response.choices[0].message.content || "No response generated.";
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`AI generation failed: ${error.message}`);
+            }
+            throw new Error("AI generation failed with unknown error");
         }
-        if (this.provider === "mistral" && this.mistral) {
-            const response = await this.mistral.chat.completions.create({
-                model: "mistral-large-latest",
-                messages: [
-                    { role: "system", content: systemPrompt },
-                    { role: "user", content: userPrompt }
-                ],
-                temperature: 0.3,
-            });
-            return response.choices[0].message.content || "No response generated.";
-        }
-        throw new Error("No AI provider configured");
+    }
+    async generateOpenAI(systemPrompt, userPrompt) {
+        if (!this.openai)
+            throw new Error("OpenAI client not initialized");
+        const response = await this.openai.chat.completions.create({
+            model: "gpt-4o-mini",
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: userPrompt },
+            ],
+            temperature: 0.3,
+        });
+        return response.choices[0].message.content || "No response generated.";
+    }
+    async generateAnthropic(systemPrompt, userPrompt) {
+        if (!this.anthropic)
+            throw new Error("Anthropic client not initialized");
+        const response = await this.anthropic.messages.create({
+            model: "claude-3-5-sonnet-20241022",
+            max_tokens: 2048,
+            system: systemPrompt,
+            messages: [{ role: "user", content: userPrompt }],
+        });
+        const textContent = response.content.find((c) => c.type === "text");
+        return textContent && textContent.type === "text"
+            ? textContent.text
+            : "No response generated.";
+    }
+    async generateGemini(systemPrompt, userPrompt) {
+        if (!this.gemini)
+            throw new Error("Gemini client not initialized");
+        const model = this.gemini.getGenerativeModel({ model: "gemini-1.5-flash" });
+        const result = await model.generateContent(`${systemPrompt}\n\n${userPrompt}`);
+        return result.response.text();
+    }
+    async generateDeepSeek(systemPrompt, userPrompt) {
+        if (!this.deepseek)
+            throw new Error("DeepSeek client not initialized");
+        const response = await this.deepseek.chat.completions.create({
+            model: "deepseek-chat",
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: userPrompt },
+            ],
+            temperature: 0.3,
+        });
+        return response.choices[0].message.content || "No response generated.";
+    }
+    async generateMistral(systemPrompt, userPrompt) {
+        if (!this.mistral)
+            throw new Error("Mistral client not initialized");
+        const response = await this.mistral.chat.completions.create({
+            model: "mistral-large-latest",
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: userPrompt },
+            ],
+            temperature: 0.3,
+        });
+        return response.choices[0].message.content || "No response generated.";
     }
     getProviderName() {
         const names = {
@@ -138,9 +172,12 @@ export class AIClient {
             anthropic: "Anthropic Claude",
             gemini: "Google Gemini",
             deepseek: "DeepSeek",
-            mistral: "Mistral AI"
+            mistral: "Mistral AI",
         };
         return names[this.provider];
     }
+    getProvider() {
+        return this.provider;
+    }
 }
 export const aiClient = new AIClient();

package/dist/lib/answer.js

@@ -1,6 +1,6 @@
 import OpenAI from "openai";
 import dotenv from "dotenv";
-dotenv.config();
+dotenv.config({ quiet: true });
 const openai = new OpenAI({
     apiKey: process.env.QUACKSTACK_OPENAI_API_KEY,
 });

package/dist/lib/context-generator.js

@@ -0,0 +1,207 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { search } from "../commands/search.js";
+export async function generateCodebaseDoc(projectName) {
+    console.log("🔍 Analyzing your codebase...\n");
+    const queries = [
+        "What is the overall architecture and design patterns used?",
+        "What are the main entry points and how does the application start?",
+        "What are the core features and functionalities?",
+        "What external APIs, services, and dependencies are used?",
+        "What is the database schema and data flow?",
+        "What are the key algorithms or business logic implementations?",
+    ];
+    let doc = `# ${projectName} - Codebase Documentation\n\n`;
+    doc += `**Auto-generated by QuackStack** | Last updated: ${new Date().toLocaleString()}\n\n`;
+    doc += `This document provides a high-level overview of the codebase architecture, key components, and design decisions.\n\n`;
+    doc += `---\n\n`;
+    doc += `## 📋 Table of Contents\n\n`;
+    queries.forEach((q, i) => {
+        const anchor = q.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+        doc += `${i + 1}. [${q}](#${anchor})\n`;
+    });
+    doc += `\n---\n\n`;
+    for (const query of queries) {
+        try {
+            const { answer, sources } = await search(query, projectName);
+            doc += `## ${query}\n\n`;
+            doc += `${answer}\n\n`;
+            if (sources.length > 0) {
+                doc += `### 📁 Key Files\n\n`;
+                sources.slice(0, 5).forEach(s => {
+                    doc += `- \`${s.filePath}\``;
+                    if (s.functionName) {
+                        doc += ` - ${s.functionName}`;
+                    }
+                    doc += `\n`;
+                });
+                doc += `\n`;
+            }
+            doc += `---\n\n`;
+        }
+        catch (e) {
+            console.error(`Error analyzing: ${query}`);
+        }
+    }
+    doc += `## 📂 Project Structure\n\n`;
+    doc += '```\n';
+    doc += await getProjectStructure(process.cwd());
+    doc += '```\n\n';
+    doc += `---\n\n`;
+    doc += `## 🚀 Getting Started\n\n`;
+    doc += `### Prerequisites\n`;
+    doc += `Check \`package.json\` for dependencies and Node.js version requirements.\n\n`;
+    doc += `### Installation\n`;
+    doc += '```bash\n';
+    doc += 'npm install\n';
+    doc += '```\n\n';
+    doc += `### Running the Project\n`;
+    doc += `Refer to \`package.json\` scripts section for available commands.\n\n`;
+    doc += `---\n\n`;
+    doc += `## 🔄 Updating This Document\n\n`;
+    doc += `This documentation is auto-generated. To regenerate:\n\n`;
+    doc += '```bash\n';
+    doc += 'quack --docs\n';
+    doc += '```\n\n';
+    doc += `For interactive codebase Q&A, run \`quack\` in your terminal.\n`;
+    const docPath = path.join(process.cwd(), "CODEBASE.md");
+    fs.writeFileSync(docPath, doc, "utf-8");
+    console.log(`✅ Generated ${docPath}`);
+}
+export async function generateContextFiles(projectName) {
+    console.log("🔍 Generating context for AI coding assistants...\n");
+    const queries = [
+        "What is the overall architecture of this project?",
+        "What are the main entry points and how does the code flow?",
+        "What are the key functions and classes?",
+        "What external dependencies and APIs are used?",
+        "What is the project structure and organization?",
+    ];
+    let baseContext = `# ${projectName} - Codebase Context\n\n`;
+    baseContext += `Generated: ${new Date().toISOString()}\n\n`;
+    baseContext += "This file is auto-generated by QuackStack to provide AI assistants with codebase context.\n\n";
+    baseContext += "---\n\n";
+    for (const query of queries) {
+        try {
+            const { answer, sources } = await search(query, projectName);
+            baseContext += `## ${query}\n\n${answer}\n\n`;
+            if (sources.length > 0) {
+                baseContext += "**Key files:**\n";
+                sources.slice(0, 3).forEach(s => {
+                    baseContext += `- ${s.filePath}\n`;
+                });
+                baseContext += "\n";
+            }
+        }
+        catch (e) {
+            console.error(`Error generating context for: ${query}`);
+        }
+    }
+    baseContext += "---\n\n## Project Structure\n\n";
+    baseContext += await getProjectStructure(process.cwd());
+    await generateCursorRules(baseContext);
+    await generateWindsurfContext(baseContext);
+    await generateClineContext(baseContext);
+    await generateContinueContext(baseContext);
+    await generateAiderContext(baseContext);
+    console.log("\n✅ Context files generated for:");
+    console.log("  - Cursor (.cursorrules)");
+    console.log("  - Windsurf (.windsurfrules)");
+    console.log("  - Cline (.clinerules)");
+    console.log("  - Continue (.continuerules)");
+    console.log("  - Aider (.aider.conf.yml)");
+    console.log("\n💡 Your AI coding assistant will now have full codebase context!");
+}
+async function generateCursorRules(context) {
+    const cursorPath = path.join(process.cwd(), ".cursorrules");
+    fs.writeFileSync(cursorPath, context, "utf-8");
+}
+async function generateWindsurfContext(context) {
+    const windsurfPath = path.join(process.cwd(), ".windsurfrules");
+    fs.writeFileSync(windsurfPath, context, "utf-8");
+}
+async function generateClineContext(context) {
+    const clinePath = path.join(process.cwd(), ".clinerules");
+    fs.writeFileSync(clinePath, context, "utf-8");
+}
+async function generateContinueContext(context) {
+    const continueDir = path.join(process.cwd(), ".continue");
+    if (!fs.existsSync(continueDir)) {
+        fs.mkdirSync(continueDir, { recursive: true });
+    }
+    const continuePath = path.join(continueDir, "context.md");
+    fs.writeFileSync(continuePath, context, "utf-8");
+}
+async function generateAiderContext(context) {
+    const aiderPath = path.join(process.cwd(), ".aider.conf.yml");
+    const aiderConfig = `# Aider configuration with QuackStack context
+# Project: ${path.basename(process.cwd())}
+
+# Context file
+read:
+  - .aider.context.md
+
+# Model settings
+model: gpt-4o-mini
+edit-format: whole
+`;
+    fs.writeFileSync(aiderPath, aiderConfig, "utf-8");
+    fs.writeFileSync(path.join(process.cwd(), ".aider.context.md"), context, "utf-8");
+}
+export async function updateGlobalContext(projectName) {
+    const quackDir = path.join(os.homedir(), ".quackstack");
+    if (!fs.existsSync(quackDir)) {
+        fs.mkdirSync(quackDir, { recursive: true });
+    }
+    const contextPath = path.join(quackDir, "contexts.json");
+    let contexts = {};
+    if (fs.existsSync(contextPath)) {
+        contexts = JSON.parse(fs.readFileSync(contextPath, "utf-8"));
+    }
+    const { answer, sources } = await search("Give a brief overview of what this project does and its main components", projectName);
+    contexts[projectName] = {
+        path: process.cwd(),
+        overview: answer,
+        topFiles: sources.slice(0, 5).map(s => s.filePath),
+        lastUpdated: new Date().toISOString(),
+    };
+    fs.writeFileSync(contextPath, JSON.stringify(contexts, null, 2), "utf-8");
+}
+export function watchAndUpdateContext(projectName) {
+    let timeout;
+    fs.watch(process.cwd(), { recursive: true }, (eventType, filename) => {
+        if (!filename || filename.includes("node_modules") || filename.includes(".git")) {
+            return;
+        }
+        clearTimeout(timeout);
+        timeout = setTimeout(async () => {
+            console.log("📝 Detected changes, updating context...");
+            await generateContextFiles(projectName);
+        }, 5000);
+    });
+    console.log("👀 Watching for file changes...");
+}
+async function getProjectStructure(dir, prefix = "", maxDepth = 3, currentDepth = 0) {
+    if (currentDepth >= maxDepth)
+        return "";
+    let structure = "";
+    const ignoreDirs = ["node_modules", ".git", "dist", "build", ".next"];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true })
+            .filter(e => !ignoreDirs.includes(e.name))
+            .slice(0, 20);
+        entries.forEach((entry, index) => {
+            const isLast = index === entries.length - 1;
+            const connector = isLast ? "└── " : "├── ";
+            structure += `${prefix}${connector}${entry.name}\n`;
+            if (entry.isDirectory() && currentDepth < maxDepth - 1) {
+                const newPrefix = prefix + (isLast ? "    " : "│   ");
+                structure += getProjectStructure(path.join(dir, entry.name), newPrefix, maxDepth, currentDepth + 1);
+            }
+        });
+    }
+    catch (e) {
+    }
+    return structure;
+}

package/dist/lib/embeddings.js

@@ -1,6 +1,6 @@
 import OpenAI from "openai";
 import dotenv from "dotenv";
-dotenv.config();
+dotenv.config({ quiet: true });
 const openai = new OpenAI({
     apiKey: process.env.QUACKSTACK_OPENAI_API_KEY,
 });

package/dist/lib/local-embeddings.js

@@ -0,0 +1,66 @@
+import crypto from "crypto";
+export class LocalEmbeddings {
+    idf = new Map();
+    documents = [];
+    tokenize(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9_\s]/g, " ")
+            .split(/\s+/)
+            .filter(t => t.length > 2);
+    }
+    computeTF(tokens) {
+        const tf = new Map();
+        tokens.forEach(token => {
+            tf.set(token, (tf.get(token) || 0) + 1);
+        });
+        tokens.forEach(token => {
+            tf.set(token, tf.get(token) / tokens.length);
+        });
+        return tf;
+    }
+    computeIDF(documents) {
+        const docCount = documents.length;
+        const termDocCount = new Map();
+        documents.forEach(doc => {
+            const uniqueTerms = new Set(doc);
+            uniqueTerms.forEach(term => {
+                termDocCount.set(term, (termDocCount.get(term) || 0) + 1);
+            });
+        });
+        termDocCount.forEach((count, term) => {
+            this.idf.set(term, Math.log(docCount / count));
+        });
+    }
+    addDocuments(docs) {
+        this.documents = docs;
+        const tokenizedDocs = docs.map(d => this.tokenize(d));
+        this.computeIDF(tokenizedDocs);
+    }
+    getVector(text) {
+        const tokens = this.tokenize(text);
+        const tf = this.computeTF(tokens);
+        const vector = [];
+        const allTerms = Array.from(this.idf.keys());
+        allTerms.forEach(term => {
+            const tfValue = tf.get(term) || 0;
+            const idfValue = this.idf.get(term) || 0;
+            vector.push(tfValue * idfValue);
+        });
+        return vector;
+    }
+    cosineSimilarity(a, b) {
+        let dot = 0, normA = 0, normB = 0;
+        const len = Math.min(a.length, b.length);
+        for (let i = 0; i < len; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
+    }
+    hash(text) {
+        return crypto.createHash("md5").update(text).digest("hex").slice(0, 16);
+    }
+}
+export const localEmbeddings = new LocalEmbeddings();

package/dist/lib/local-search.js

@@ -0,0 +1,66 @@
+import crypto from "crypto";
+export class LocalEmbeddings {
+    idf = new Map();
+    documents = [];
+    tokenize(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9_\s]/g, " ")
+            .split(/\s+/)
+            .filter(t => t.length > 2);
+    }
+    computeTF(tokens) {
+        const tf = new Map();
+        tokens.forEach(token => {
+            tf.set(token, (tf.get(token) || 0) + 1);
+        });
+        tokens.forEach(token => {
+            tf.set(token, tf.get(token) / tokens.length);
+        });
+        return tf;
+    }
+    computeIDF(documents) {
+        const docCount = documents.length;
+        const termDocCount = new Map();
+        documents.forEach(doc => {
+            const uniqueTerms = new Set(doc);
+            uniqueTerms.forEach(term => {
+                termDocCount.set(term, (termDocCount.get(term) || 0) + 1);
+            });
+        });
+        termDocCount.forEach((count, term) => {
+            this.idf.set(term, Math.log(docCount / count));
+        });
+    }
+    addDocuments(docs) {
+        this.documents = docs;
+        const tokenizedDocs = docs.map(d => this.tokenize(d));
+        this.computeIDF(tokenizedDocs);
+    }
+    getVector(text) {
+        const tokens = this.tokenize(text);
+        const tf = this.computeTF(tokens);
+        const vector = [];
+        const allTerms = Array.from(this.idf.keys());
+        allTerms.forEach(term => {
+            const tfValue = tf.get(term) || 0;
+            const idfValue = this.idf.get(term) || 0;
+            vector.push(tfValue * idfValue);
+        });
+        return vector;
+    }
+    cosineSimilarity(a, b) {
+        let dot = 0, normA = 0, normB = 0;
+        const len = Math.min(a.length, b.length);
+        for (let i = 0; i < len; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
+    }
+    hash(text) {
+        return crypto.createHash("md5").update(text).digest("hex").slice(0, 16);
+    }
+}
+export const localEmbeddings = new LocalEmbeddings();

package/dist/lib/session-generator.js

@@ -0,0 +1,56 @@
+export class SessionManager {
+    projectName;
+    sessionId;
+    conversations = [];
+    constructor(projectName) {
+        this.projectName = projectName;
+        this.sessionId = new Date().toISOString();
+    }
+    async addConversation(query, answer, provider) {
+        this.conversations.push({
+            query,
+            answer,
+            provider,
+            timestamp: new Date(),
+        });
+        await this.saveToDatabase();
+    }
+    async saveToDatabase() {
+        const sessionData = {
+            projectName: this.projectName,
+            sessionId: this.sessionId,
+            conversations: JSON.stringify(this.conversations),
+        };
+        const fs = await import("fs");
+        const path = await import("path");
+        const os = await import("os");
+        const sessionDir = path.join(os.homedir(), ".quackstack", "sessions");
+        if (!fs.existsSync(sessionDir)) {
+            fs.mkdirSync(sessionDir, { recursive: true });
+        }
+        const sessionFile = path.join(sessionDir, `${this.projectName}-${this.sessionId}.json`);
+        fs.writeFileSync(sessionFile, JSON.stringify(this.conversations, null, 2));
+    }
+    getConversationHistory() {
+        return this.conversations
+            .map(c => `Q: ${c.query}\nA: ${c.answer}\n(via ${c.provider})\n`)
+            .join("\n---\n\n");
+    }
+    async loadPreviousSession() {
+        const fs = await import("fs");
+        const path = await import("path");
+        const os = await import("os");
+        const sessionDir = path.join(os.homedir(), ".quackstack", "sessions");
+        if (!fs.existsSync(sessionDir))
+            return;
+        const files = fs.readdirSync(sessionDir)
+            .filter(f => f.startsWith(this.projectName))
+            .sort()
+            .reverse();
+        if (files.length > 0) {
+            const latestSession = path.join(sessionDir, files[0]);
+            const data = JSON.parse(fs.readFileSync(latestSession, "utf-8"));
+            this.conversations = data;
+        }
+    }
+}

package/dist/repl.js

@@ -1,4 +1,5 @@
 import readline from "readline";
+import chalk from "chalk";
 import { ingest } from "./commands/ingest.js";
 import { search } from "./commands/search.js";
 import { client } from "./lib/database.js";
@@ -20,55 +21,59 @@ async function ensureIngested(forceReindex = false) {
         console.log("✅ Indexing complete!\n");
     }
 }
+function stripMarkdown(text) {
+    return text
+        .replace(/\*\*(.+?)\*\*/g, chalk.bold('$1'))
+        .replace(/\*(.+?)\*/g, chalk.italic('$1'))
+        .replace(/`(.+?)`/g, chalk.cyan('$1'))
+        .replace(/^#{1,6}\s+(.+)$/gm, chalk.bold.blue('$1'));
+}
 export async function startREPL(forceReindex = false) {
     await ensureIngested(forceReindex);
+    console.log("💡 Tip: Press Ctrl+C to exit\n");
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
         terminal: true
     });
-    console.log("💡 Tip: Press Ctrl+C to exit\n");
-    const askQuestion = () => {
-        rl.question("🐥 Quack! How can I help? > ", async (input) => {
-            const trimmed = input.trim();
-            if (!trimmed) {
-                askQuestion();
-                return;
-            }
-            try {
-                rl.pause();
-                const { answer, sources } = await search(trimmed, PROJECT_NAME);
-                console.log(`\n${answer}\n`);
-                const detailRL = readline.createInterface({
-                    input: process.stdin,
-                    output: process.stdout,
-                    terminal: true
-                });
-                detailRL.question("💡 Want more details? (y/n) > ", (ans) => {
-                    if (ans.toLowerCase() === "y") {
-                        console.log("\n📚 Relevant Code:\n");
-                        sources.slice(0, 3).forEach((r, i) => {
-                            console.log(`[${i + 1}] ${r.filePath} (relevance: ${(r.score * 100).toFixed(1)}%)`);
-                            console.log(`${r.content}\n`);
-                            console.log("---\n");
-                        });
-                    }
-                    detailRL.close();
-                    console.log();
-                    rl.resume();
-                    askQuestion();
+    let waitingForDetails = false;
+    let currentSources = [];
+    rl.on("line", async (input) => {
+        const trimmed = input.trim().toLowerCase();
+        if (waitingForDetails) {
+            waitingForDetails = false;
+            if (trimmed === "y" || trimmed === "yes") {
+                console.log("\n📚 Relevant Code:\n");
+                currentSources.slice(0, 3).forEach((r, i) => {
+                    console.log(chalk.dim(`[${i + 1}] ${r.filePath} (relevance: ${(r.score * 100).toFixed(1)}%)`));
+                    console.log(chalk.gray(r.content));
+                    console.log(chalk.dim("---\n"));
                 });
             }
-            catch (error) {
-                console.error("❌ Error:", error instanceof Error ? error.message : "Unknown error");
-                rl.resume();
-                askQuestion();
-            }
-        });
-    };
-    askQuestion();
+            console.log();
+            rl.prompt();
+            return;
+        }
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+        try {
+            const { answer, sources } = await search(input, PROJECT_NAME);
+            currentSources = sources;
+            console.log("\n" + stripMarkdown(answer) + "\n");
+            waitingForDetails = true;
+            process.stdout.write("💡 Want more details? (y/n) > ");
+        }
+        catch (error) {
+            console.error(chalk.red("❌ Error:"), error instanceof Error ? error.message : "Unknown error");
+            rl.prompt();
+        }
+    });
     rl.on("close", () => {
         console.log("\n👋 Happy coding!");
         process.exit(0);
     });
+    rl.setPrompt("🐥 Quack! How can I help? > ");
+    rl.prompt();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quackstack",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Your cracked unpaid intern for all things codebase related! AI-powered codebase search and Q&A.",
   "type": "module",
   "main": "dist/cli.cjs",
@@ -68,6 +68,7 @@
     "chalk": "^5.6.2",
     "chalk-animation": "^2.0.3",
     "commander": "^14.0.1",
+    "crypto": "^1.0.1",
     "dotenv": "^17.2.3",
     "openai": "^6.0.1",
     "prisma": "^6.16.3"