quackstack 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 woustachemax
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,288 @@
+# QuackStack 🐥
+
+**Your cracked unpaid intern for all things codebase related!**
+
+QuackStack is an interactive CLI tool that indexes your codebase using AI embeddings and lets you ask questions about it conversationally. Perfect for understanding unfamiliar code, onboarding to new projects, or giving your AI coding assistant persistent context.
+
+
+## ✨ Features
+
+* 🚀 **Zero-config** - Just run `quack` in any project directory
+* 🧠 **Smart code parsing** - Automatically extracts functions and classes
+* 💬 **Interactive REPL** - Ask questions conversationally, stays open until Ctrl+C
+* 🤖 **Multi-AI support** - Works with OpenAI, Claude, Gemini, DeepSeek, or Mistral
+* 🎯 **Cursor integration** - Auto-generate `.cursorrules` for Cursor AI
+* 📦 **Local database** - Your code stays on your infrastructure
+* 🌍 **Multi-language** - Supports JS/TS, Python, Go, Rust, Java, C/C++, C#, Ruby, PHP, Swift, Kotlin, and more
+
+
+## 📦 Installation
+
+### Global Install (Recommended)
+
+```bash
+pnpm add -g quackstack
+
+npm install -g quackstack
+```
+
+### Local Development
+
+```bash
+git clone https://github.com/woustachemax/quackstack.git
+cd quackstack
+pnpm install
+pnpm build
+```
+
+
+## ⚙️ Setup
+
+### 1. Create `.env` in your project root
+
+```bash
+# REQUIRED!
+QUACKSTACK_DATABASE_URL=postgresql://user:pass@host:port/dbname
+
+# Choose ONE AI provider:
+
+# Option 1: OpenAI (RECOOMMENDED!)
+QUACKSTACK_OPENAI_KEY=sk-...
+
+# Option 2: Anthropic Claude
+QUACKSTACK_ANTHROPIC_KEY=sk-ant-...
+
+# Option 3: Google Gemini (has free tier!)
+QUACKSTACK_GEMINI_KEY=AIza...
+
+# Option 4: DeepSeek (cheapest option)
+QUACKSTACK_DEEPSEEK_KEY=sk-...
+
+# Option 5: Mistral AI
+QUACKSTACK_MISTRAL_KEY=...
+
+# NOTE: If using Claude/Gemini/Mistral, you still NEED OpenAI for embeddings:
+QUACKSTACK_EMBEDDING_KEY=sk-...
+```
+
+### 2. Initialize database
+
+```bash
+npx prisma generate
+npx prisma db push
+```
+
+
+## 🚀 Usage
+
+### Interactive Mode (Default)
+
+```bash
+quack
+
+
+🐥 Quack! How can I help? > where is authentication handled?
+
+# Answer appears with context
+# Press Ctrl+C to exit
+```
+
+### Generate Cursor Context
+
+```bash
+quack --cursor
+
+# Creates .cursorrules file with:
+# - Architecture overview
+# - Main entry points
+# - Key functions and files
+# - Project structure
+
+# Cursor AI automatically reads this file!
+```
+
+### Watch Mode (Auto-update Cursor)
+
+```bash
+quack --watch
+
+# Watches for file changes
+# Auto-regenerates .cursorrules
+# Keep running in background during development
+```
+
+### Force Reindex
+
+```bash
+quack --reindex
+
+# Clears old index and re-scans entire codebase
+```
+
+
+## 📖 Example Session
+
+```bash
+$ quack
+Welcome to QuackStack! 🐥
+🔍 Indexing your codebase (this may take a moment)...
+✅ Indexing complete!
+
+💡 Tip: Press Ctrl+C to exit
+
+🐥 Quack! How can I help? > how does the search function work?
+
+The search function converts your query to embeddings, compares them
+against stored code embeddings using cosine similarity, ranks results,
+and feeds the top matches to the AI for a conversational answer.
+
+Implementation is in src/commands/search.ts
+
+💡 Want more details? (y/n) > y
+
+📚 Relevant Code:
+
+[1] src/commands/search.ts (relevance: 87.3%)
+export async function search(query: string, projectName: string) {
+  const queryEmbedding = await aiClient.getEmbeddings(query);
+  const snippets = await client.codeSnippet.findMany({
+    where: { projectName },
+  });
+  // ... cosine similarity ranking ...
+}
+
+
+🐥 Quack! How can I help? > where are embeddings generated?
+
+Vector embeddings are generated in src/lib/ai-provider.ts using
+the getEmbeddings() method with OpenAI's text-embedding-3-large model.
+
+💡 Want more details? (y/n) > n
+
+🐥 Quack! How can I help? > ^C
+👋 Happy coding!
+```
+
+
+## 🛠️ How It Works
+
+1. **Scanning** - Finds all code files (ignoring `node_modules`, `.git`, etc.)
+2. **Parsing** - Uses AST parsing to extract functions/classes from JS/TS
+3. **Chunking** - Breaks other languages into logical chunks
+4. **Embedding** - Generates vector embeddings for each code chunk
+5. **Storage** - Saves to your PostgreSQL/Neon database
+6. **Search** - Semantic search + AI-powered conversational answers
+
+
+## 🎯 Use Cases
+
+- **Context switching** - Quickly understand projects you haven't touched in months
+- **Onboarding** - New team members can ask questions instead of reading docs
+- **Code archaeology** - Find implementations without grepping
+- **AI coding assistants** - Give Cursor/Claude/ChatGPT persistent codebase context
+- **Documentation** - Auto-generate explanations of how things work
+
+
+## 📋 Commands Reference
+
+| Command | Description |
+|---------|-------------|
+| `quack` | Start interactive REPL (auto-indexes first time) |
+| `quack --cursor` | Generate `.cursorrules` for Cursor AI |
+| `quack --watch` | Watch mode - auto-update Cursor context on file changes |
+| `quack --reindex` | Force reindex the entire codebase |
+
+
+## 🔑 Supported AI Providers
+
+| Provider | Chat | Embeddings | Cost | Setup |
+|----------|------|------------|------|-------|
+| OpenAI | ✅ GPT-4o-mini | ✅ | $$ | [Get key](https://platform.openai.com/api-keys) |
+| Anthropic | ✅ Claude 3.5 | ❌ | $$$ | [Get key](https://console.anthropic.com/) |
+| Gemini | ✅ Gemini 1.5 | ❌ | FREE | [Get key](https://aistudio.google.com/app/apikey) |
+| DeepSeek | ✅ | ✅ | $ | [Get key](https://platform.deepseek.com/) |
+| Mistral | ✅ | ❌ | $$ | [Get key](https://console.mistral.ai/) |
+
+**Note:** If you use Claude, Gemini, or Mistral for chat, you still need an OpenAI or DeepSeek key for embeddings.
+
+
+## 🗄️ Database Schema
+
+```prisma
+model codeSnippet {
+  id           Int      @id @default(autoincrement())
+  content      String
+  embedding    Json
+  filePath     String
+  projectName  String
+  language     String?
+  functionName String?
+  lineStart    Int?
+  lineEnd      Int?
+  createdAt    DateTime @default(now())
+  updatedAt    DateTime @updatedAt
+
+  @@index([projectName])
+}
+```
+
+Each project is isolated by `projectName` (uses current directory name).
+
+
+## 🌍 Supported Languages
+
+JavaScript, TypeScript, Python, Go, Rust, Java, C, C++, C#, Ruby, PHP, Swift, Kotlin, Scala, R, Vue, Svelte
+
+
+## 🎓 Development
+
+```bash
+git clone https://github.com/woustachemax/quackstack.git
+cd quackstack
+pnpm install
+
+pnpm build
+
+node dist/cli.cjs
+
+node dist/cli.cjs --cursor
+node dist/cli.cjs --watch
+```
+
+
+## 🗺️ Roadmap
+
+- [ ] Support more embedding providers (Cohere, Voyage AI)
+- [ ] Add filtering by file type, date range, author
+- [ ] Generate automatic codebase documentation
+- [ ] Export Q&A sessions as markdown docs
+- [ ] VS Code extension
+- [ ] Official Cursor plugin
+- [ ] Support for code diffs and change tracking
+- [ ] Team collaboration features
+
+
+## 🤝 Contributing
+
+Contributions welcome! Feel free to:
+- Report bugs via [GitHub Issues](https://github.com/woustachemax/quackstack/issues)
+- Submit feature requests
+- Open pull requests
+
+
+## 📄 License
+
+MIT
+
+
+## 💡 Pro Tips
+
+**Gemini Free Tier**: Start with Google Gemini - it's free and works great for most use cases.
+
+**DeepSeek for Production**: If you need cheap embeddings at scale, use DeepSeek (~$0.14 per million tokens).
+
+**Cursor Integration**: Run `quack --cursor` once, then `quack --watch &` in the background to keep context always fresh.
+
+**Multiple Projects**: Each project gets its own namespace in the database. Just run `quack` in different directories.
+
+**Large Codebases**: First index might take a few minutes. After that, only changed files are re-indexed.

package/dist/cli.cjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 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")
+    .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")
+    .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.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");
+        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);
+        await new Promise(() => { });
+    }
+    await (0, repl_js_1.startREPL)(options.reindex);
+});
+program.parse();

package/dist/commands/ingest.js

@@ -0,0 +1,42 @@
+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";
+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`);
+    let processedCount = 0;
+    for (const filePath of files) {
+        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);
+        }
+    }
+    if (!silent)
+        console.log(`Done! Processed ${processedCount} files.`);
+}

package/dist/commands/search.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { client } from "../lib/database.js";
+import { aiClient } from "../lib/ai-provider.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));
+}
+export async function search(query, projectName) {
+    const queryEmbedding = await aiClient.getEmbeddings(query);
+    const snippets = await client.codeSnippet.findMany({
+        where: { projectName },
+    });
+    const ranked = snippets
+        .map(snippet => ({
+        id: snippet.id,
+        content: snippet.content,
+        filePath: snippet.filePath,
+        functionName: snippet.functionName,
+        score: cosineSim(queryEmbedding, snippet.embedding),
+    }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 5);
+    const context = ranked
+        .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 };
+}

package/dist/lib/ai-provider.js

@@ -0,0 +1,146 @@
+import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import dotenv from "dotenv";
+dotenv.config();
+export class AIClient {
+    provider;
+    openai;
+    anthropic;
+    gemini;
+    deepseek;
+    mistral;
+    constructor() {
+        if (process.env.QUACKSTACK_OPENAI_KEY) {
+            this.provider = "openai";
+            this.openai = new 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
+            });
+        }
+        else if (process.env.QUACKSTACK_GEMINI_KEY) {
+            this.provider = "gemini";
+            this.gemini = new GoogleGenerativeAI(process.env.QUACKSTACK_GEMINI_KEY);
+        }
+        else if (process.env.QUACKSTACK_DEEPSEEK_KEY) {
+            this.provider = "deepseek";
+            this.deepseek = new OpenAI({
+                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({
+                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)");
+        }
+    }
+    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;
+        }
+        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 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();
+        }
+        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.";
+        }
+        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");
+    }
+    getProviderName() {
+        const names = {
+            openai: "OpenAI GPT",
+            anthropic: "Anthropic Claude",
+            gemini: "Google Gemini",
+            deepseek: "DeepSeek",
+            mistral: "Mistral AI"
+        };
+        return names[this.provider];
+    }
+}
+export const aiClient = new AIClient();

package/dist/lib/answer.js

@@ -0,0 +1,49 @@
+import OpenAI from "openai";
+import dotenv from "dotenv";
+dotenv.config();
+const openai = new OpenAI({
+    apiKey: process.env.QUACKSTACK_OPENAI_API_KEY,
+});
+export async function generateAnswer(query, results) {
+    const context = results
+        .map((r, i) => `[${i + 1}] ${r.filePath}\n${r.content}`)
+        .join("\n\n---\n\n");
+    const response = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        messages: [
+            {
+                role: "system",
+                content: `
+        You are a precise and context-aware coding assistant integrated into a CLI tool.
+        Your job is to answer technical questions about a users codebase using the provided file contents, function definitions, or directory structures.
+
+        Behavior:
+
+        Always reference specific files, functions, or classes when relevant (e.g., "In db/models.py, the User class...").
+
+        Be concise and factual.
+
+        Do not speculate beyond the given code snippets.
+
+        If context is missing, state clearly whats missing.
+
+        Treat user queries as about the codebase (e.g., “what does code in my db do?”) and infer meaning from filenames, docstrings, and code structure.
+
+        Example queries:
+
+        “what does code in my db do?” → Summarize DB-related modules.
+
+        “how is authentication implemented?” → Trace relevant functions/files.
+
+        “where is API routing defined?” → Identify routing logic by filename and function.
+        Always format your answers in markdown for clarity.`,
+            },
+            {
+                role: "user",
+                content: `Code context:\n\n${context}\n\nQuestion: ${query}`,
+            },
+        ],
+        temperature: 0.3,
+    });
+    return response.choices[0].message.content;
+}

package/dist/lib/chunker.js

@@ -0,0 +1,80 @@
+import * as parser from "@babel/parser";
+import traverse from "@babel/traverse";
+const traverseDefault = traverse.default || traverse;
+export function chunkCode(code, filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    if (["ts", "js", "tsx", "jsx", "mjs", "cjs"].includes(ext || "")) {
+        try {
+            return extractJSFunctions(code);
+        }
+        catch (e) {
+            console.warn(`Failed to parse ${filePath}, using simple chunking`);
+        }
+    }
+    return simpleChunk(code);
+}
+function extractJSFunctions(code) {
+    const chunks = [];
+    try {
+        const ast = parser.parse(code, {
+            sourceType: "module",
+            plugins: ["typescript", "jsx"],
+            errorRecovery: true,
+        });
+        traverseDefault(ast, {
+            FunctionDeclaration(path) {
+                if (path.node.start !== null && path.node.end !== null) {
+                    chunks.push({
+                        content: code.slice(path.node.start, path.node.end),
+                        functionName: path.node.id?.name,
+                        lineStart: path.node.loc?.start.line,
+                        lineEnd: path.node.loc?.end.line,
+                    });
+                }
+            },
+            ClassDeclaration(path) {
+                if (path.node.start !== null && path.node.end !== null) {
+                    chunks.push({
+                        content: code.slice(path.node.start, path.node.end),
+                        functionName: path.node.id?.name,
+                        lineStart: path.node.loc?.start.line,
+                        lineEnd: path.node.loc?.end.line,
+                    });
+                }
+            },
+            ArrowFunctionExpression(path) {
+                if (path.parent.type === "VariableDeclarator" &&
+                    path.node.start !== null &&
+                    path.node.end !== null) {
+                    const varDeclarator = path.parent;
+                    const functionName = varDeclarator.id.type === "Identifier"
+                        ? varDeclarator.id.name
+                        : undefined;
+                    chunks.push({
+                        content: code.slice(path.node.start, path.node.end),
+                        functionName,
+                        lineStart: path.node.loc?.start.line,
+                        lineEnd: path.node.loc?.end.line,
+                    });
+                }
+            },
+        });
+    }
+    catch (e) {
+        return simpleChunk(code);
+    }
+    return chunks.length > 0 ? chunks : simpleChunk(code);
+}
+function simpleChunk(code, maxLines = 50) {
+    const lines = code.split("\n");
+    const chunks = [];
+    for (let i = 0; i < lines.length; i += maxLines) {
+        const chunk = lines.slice(i, i + maxLines).join("\n");
+        chunks.push({
+            content: chunk,
+            lineStart: i + 1,
+            lineEnd: Math.min(i + maxLines, lines.length),
+        });
+    }
+    return chunks;
+}

package/dist/lib/cursor-context.js

@@ -0,0 +1,94 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { search } from "../commands/search.js";
+export async function generateCursorContext(projectName) {
+    const cursorRulesPath = path.join(process.cwd(), ".cursorrules");
+    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?",
+    ];
+    let context = "# QuackStack Codebase Context\n\n";
+    context += "This file is auto-generated by QuackStack to provide AI assistants with codebase context.\n\n";
+    context += "---\n\n";
+    for (const query of queries) {
+        try {
+            const { answer, sources } = await search(query, projectName);
+            context += `## ${query}\n\n${answer}\n\n`;
+            if (sources.length > 0) {
+                context += "**Key files:**\n";
+                sources.slice(0, 3).forEach(s => {
+                    context += `- ${s.filePath}\n`;
+                });
+                context += "\n";
+            }
+        }
+        catch (e) {
+            console.error(`Error generating context for: ${query}`);
+        }
+    }
+    context += "---\n\n## Project Structure\n\n";
+    context += await getProjectStructure(process.cwd());
+    fs.writeFileSync(cursorRulesPath, context, "utf-8");
+    console.log(`✅ Generated .cursorrules at ${cursorRulesPath}`);
+    return cursorRulesPath;
+}
+export async function updateCursorGlobalContext(projectName) {
+    const cursorDir = path.join(os.homedir(), ".cursor");
+    if (!fs.existsSync(cursorDir)) {
+        fs.mkdirSync(cursorDir, { recursive: true });
+    }
+    const globalContextPath = path.join(cursorDir, "quackstack-contexts.json");
+    let contexts = {};
+    if (fs.existsSync(globalContextPath)) {
+        contexts = JSON.parse(fs.readFileSync(globalContextPath, "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(globalContextPath, JSON.stringify(contexts, null, 2), "utf-8");
+    console.log(`✅ Updated global Cursor context`);
+}
+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;
+}
+export function watchAndUpdateCursor(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 Cursor context...");
+            await generateCursorContext(projectName);
+        }, 5000);
+    });
+    console.log("👀 Watching for file changes...");
+}

package/dist/lib/database.js

@@ -0,0 +1,41 @@
+import { PrismaClient } from "@prisma/client";
+export const client = new PrismaClient();
+export const saveToDB = async (data) => {
+    try {
+        const result = await client.codeSnippet.create({
+            data: {
+                ...data,
+                embedding: data.embedding,
+            },
+        });
+        return result;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            console.error(`Error saving to DB: ${e.message}`);
+        }
+        else {
+            console.error(`Unknown error saving to DB:`, e);
+        }
+        throw e;
+    }
+};
+export const getFromDB = async (projectName) => {
+    try {
+        const results = await client.codeSnippet.findMany({
+            where: {
+                projectName: projectName
+            }
+        });
+        return results;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            console.error(`Error fetching from DB: ${e.message}`);
+        }
+        else {
+            console.error(`Unknown error fetching from DB:`, e);
+        }
+        throw e;
+    }
+};

package/dist/lib/embeddings.js

@@ -0,0 +1,15 @@
+import OpenAI from "openai";
+import dotenv from "dotenv";
+dotenv.config();
+const openai = new OpenAI({
+    apiKey: process.env.QUACKSTACK_OPENAI_API_KEY,
+});
+export async function getEmbeddings(content) {
+    const response = await openai.embeddings.create({
+        model: "text-embedding-3-large",
+        input: content
+    });
+    // console.log("Embedding response:", response.data[0].embedding);
+    return response.data[0].embedding;
+}
+// getEmbeddings("Hello, world! This is a test embedding.");

package/dist/lib/scanner.js

@@ -0,0 +1,57 @@
+import fs from "fs";
+import path from "path";
+const IGNORE_DIRS = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "target",
+    "__pycache__",
+    ".next",
+    ".nuxt",
+    "coverage",
+    ".cache",
+    "vendor",
+    "tmp",
+    "temp",
+];
+const DEFAULT_EXTENSIONS = [
+    ".ts", ".js", ".tsx", ".jsx", ".mjs", ".cjs",
+    ".py", ".pyw",
+    ".go",
+    ".rs",
+    ".java",
+    ".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx",
+    ".cs",
+    ".rb", ".php", ".swift", ".kt", ".kts", ".scala", ".r",
+    ".vue", ".svelte",
+];
+export async function scanDir(rootDir, exts = DEFAULT_EXTENSIONS) {
+    const files = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch (e) {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (IGNORE_DIRS.includes(entry.name)) {
+                    continue;
+                }
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (exts.includes(ext)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    await walk(rootDir);
+    return files;
+}

package/dist/repl.js

@@ -0,0 +1,70 @@
+import readline from "readline";
+import { ingest } from "./commands/ingest.js";
+import { search } from "./commands/search.js";
+import { client } from "./lib/database.js";
+import path from "path";
+const PROJECT_NAME = path.basename(process.cwd());
+async function ensureIngested(forceReindex = false) {
+    const count = await client.codeSnippet.count({
+        where: { projectName: PROJECT_NAME }
+    });
+    if (count === 0 || forceReindex) {
+        if (forceReindex && count > 0) {
+            console.log("🗑️  Clearing old index...");
+            await client.codeSnippet.deleteMany({
+                where: { projectName: PROJECT_NAME }
+            });
+        }
+        console.log("🔍 Indexing your codebase (this may take a moment)...");
+        await ingest(process.cwd(), PROJECT_NAME, true);
+        console.log("✅ Indexing complete!\n");
+    }
+}
+export async function startREPL(forceReindex = false) {
+    await ensureIngested(forceReindex);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: "🐥 Quack! How can I help? > "
+    });
+    console.log("💡 Tip: Press Ctrl+C to exit\n");
+    rl.prompt();
+    rl.on("line", async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+        try {
+            const { answer, sources } = await search(trimmed, PROJECT_NAME);
+            console.log(`\n${answer}\n`);
+            await new Promise((resolve) => {
+                const detailRL = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout
+                });
+                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();
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            console.error("❌ Error:", error instanceof Error ? error.message : "Unknown error");
+        }
+        rl.prompt();
+    });
+    rl.on("close", () => {
+        console.log("\n👋 Happy coding!");
+        process.exit(0);
+    });
+}

package/dist/test/tests.js

@@ -0,0 +1,17 @@
+// import { getfromDB, saveToDB } from "../lib/database.js";
+export {};
+// async function main() {
+//   await saveToDB({
+//     content: "function hello() { console.log('hi'); }",
+//     embedding: [0.012, -0.034, 0.056],
+//     filePath: "src/hello.ts",
+//     projectName: "test-project",
+//     language: "typescript",
+//     lineStart: 1,
+//     lineEnd: 3,
+//   });
+// }
+// // async function main() {
+// //   await getfromDB("test-project");
+// // }
+// main();

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "quackstack",
+  "version": "1.0.0",
+  "description": "Your cracked unpaid intern for all things codebase related! AI-powered codebase search and Q&A.",
+  "type": "module",
+  "main": "dist/cli.cjs",
+  "bin": {
+    "quack": "./dist/cli.cjs"
+  },
+  "files": [
+    "dist",
+    "prisma",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b && node dist/cli.cjs",
+    "prepare": "prisma generate",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "embeddings",
+    "code-search",
+    "codebase",
+    "cursor",
+    "cursor-ai",
+    "semantic-search",
+    "code-assistant",
+    "openai",
+    "claude",
+    "gemini",
+    "deepseek",
+    "mistral"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/woustachemax/quackstack.git"
+  },
+  "author": "woustachemax",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.68.0",
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
+    "@google/generative-ai": "^0.24.1",
+    "@prisma/client": "^6.16.3",
+    "chalk": "^5.6.2",
+    "chalk-animation": "^2.0.3",
+    "commander": "^14.0.1",
+    "dotenv": "^17.2.3",
+    "openai": "^6.0.1"
+  },
+  "devDependencies": {
+    "@types/babel__traverse": "^7.28.0",
+    "@types/chalk-animation": "^1.6.3",
+    "@types/node": "^20.0.0",
+    "prisma": "^6.16.3",
+    "typescript": "^5.9.3"
+  }
+}

package/prisma/migrations/20251002215048_init/migration.sql

@@ -0,0 +1,19 @@
+-- CreateTable
+CREATE TABLE "CodeSnippet" (
+    "id" SERIAL NOT NULL,
+    "content" TEXT NOT NULL,
+    "embedding" TEXT NOT NULL,
+    "filePath" TEXT NOT NULL,
+    "projectName" TEXT NOT NULL,
+    "language" TEXT,
+    "functionName" TEXT,
+    "lineStart" INTEGER,
+    "lineEnd" INTEGER,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "CodeSnippet_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "CodeSnippet_projectName_idx" ON "CodeSnippet"("projectName");

package/prisma/migrations/20251002220417_embedding_json/migration.sql

@@ -0,0 +1,9 @@
+/*
+  Warnings:
+
+  - Changed the type of `embedding` on the `CodeSnippet` table. No cast exists, the column would be dropped and recreated, which cannot be done if there is data, since the column is required.
+
+*/
+-- AlterTable
+ALTER TABLE "CodeSnippet" DROP COLUMN "embedding",
+ADD COLUMN     "embedding" JSONB NOT NULL;

package/prisma/migrations/20251002222539_code_snipper/migration.sql

@@ -0,0 +1,28 @@
+/*
+  Warnings:
+
+  - You are about to drop the `CodeSnippet` table. If the table is not empty, all the data it contains will be lost.
+
+*/
+-- DropTable
+DROP TABLE "public"."CodeSnippet";
+
+-- CreateTable
+CREATE TABLE "codeSnippet" (
+    "id" SERIAL NOT NULL,
+    "content" TEXT NOT NULL,
+    "embedding" JSONB NOT NULL,
+    "filePath" TEXT NOT NULL,
+    "projectName" TEXT NOT NULL,
+    "language" TEXT,
+    "functionName" TEXT,
+    "lineStart" INTEGER,
+    "lineEnd" INTEGER,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "codeSnippet_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "codeSnippet_projectName_idx" ON "codeSnippet"("projectName");

package/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "postgresql"

package/prisma/schema.prisma

@@ -0,0 +1,30 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("QUACKSTACK_DATABASE_URL")
+}
+
+model codeSnippet {
+  id        Int      @id @default(autoincrement())
+  content   String
+  embedding    Json   
+  filePath     String   
+  projectName  String 
+  language     String?  
+  functionName String?
+  lineStart    Int?     
+  lineEnd      Int?     
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([projectName])
+}