quackstack 1.0.23 → 1.0.24

package/dist/cli.cjs

@@ -12,6 +12,8 @@ const context_generator_js_1 = require("./lib/context-generator.js");
 const readme_js_1 = require("./commands/readme.js");
 const agents_js_1 = require("./commands/agents.js");
 const ai_provider_js_1 = require("./lib/ai-provider.js");
+const database_js_1 = require("./lib/database.js");
+const git_history_js_1 = require("./lib/git-history.js");
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
 const PROJECT_NAME = path_1.default.basename(process.cwd());
@@ -85,4 +87,84 @@ program
     }
     await (0, repl_js_1.startREPL)(options.reindex, options.provider, options.model);
 });
+program
+    .command("authors")
+    .description("Show contributor statistics for this project")
+    .action(async () => {
+    if (!git_history_js_1.gitHistory.isRepository()) {
+        console.log(chalk_1.default.red("❌ Not a git repository"));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.cyan("\n📊 Contributor Statistics\n"));
+    const authors = await (0, database_js_1.getProjectAuthors)(PROJECT_NAME);
+    if (authors.length === 0) {
+        console.log(chalk_1.default.yellow("No contributor data found. Run 'quack --reindex' first."));
+        process.exit(0);
+    }
+    authors.forEach((author, i) => {
+        console.log(chalk_1.default.green(`${i + 1}. ${author.author}`) + chalk_1.default.gray(` (${author.email})`));
+        console.log(chalk_1.default.white(`   ${author.totalCommits} commits | +${author.linesAdded}/-${author.linesRemoved} lines`));
+        if (author.recentActivity) {
+            const daysAgo = Math.floor((Date.now() - author.recentActivity.getTime()) / (1000 * 60 * 60 * 24));
+            console.log(chalk_1.default.gray(`   Last active ${daysAgo} days ago`));
+        }
+        if (author.filesOwned.length > 0) {
+            console.log(chalk_1.default.gray(`   Owns ${author.filesOwned.length} files`));
+        }
+        console.log();
+    });
+    console.log(chalk_1.default.cyan(`Total: ${authors.length} contributors\n`));
+});
+program
+    .command("recent")
+    .description("Show recently modified files")
+    .option("-d, --days <number>", "Number of days to look back", "7")
+    .action(async (options) => {
+    if (!git_history_js_1.gitHistory.isRepository()) {
+        console.log(chalk_1.default.red("❌ Not a git repository"));
+        process.exit(1);
+    }
+    const days = parseInt(options.days);
+    console.log(chalk_1.default.cyan(`\n📝 Files modified in last ${days} days\n`));
+    const files = await (0, database_js_1.getRecentlyModifiedFiles)(PROJECT_NAME, days);
+    if (files.length === 0) {
+        console.log(chalk_1.default.yellow(`No files modified in last ${days} days (or run 'quack --reindex')`));
+        process.exit(0);
+    }
+    files.forEach((file, i) => {
+        const daysAgo = Math.floor((Date.now() - file.lastCommitDate.getTime()) / (1000 * 60 * 60 * 24));
+        console.log(chalk_1.default.green(`${i + 1}. ${file.filePath}`));
+        console.log(chalk_1.default.gray(`   Modified by ${file.lastCommitAuthor} ${daysAgo} days ago`));
+        if (file.lastCommitMessage) {
+            console.log(chalk_1.default.white(`   "${file.lastCommitMessage.substring(0, 60)}${file.lastCommitMessage.length > 60 ? '...' : ''}"`));
+        }
+        console.log();
+    });
+    console.log(chalk_1.default.cyan(`Total: ${files.length} files\n`));
+});
+program
+    .command("git-info")
+    .description("Show git repository information")
+    .action(() => {
+    if (!git_history_js_1.gitHistory.isRepository()) {
+        console.log(chalk_1.default.red("❌ Not a git repository"));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.cyan("\n🔍 Git Repository Info\n"));
+    const branch = git_history_js_1.gitHistory.getCurrentBranch();
+    if (branch) {
+        console.log(chalk_1.default.white(`Current Branch: `) + chalk_1.default.green(branch));
+    }
+    const repoRoot = git_history_js_1.gitHistory.getRepositoryRoot();
+    console.log(chalk_1.default.white(`Repository Root: `) + chalk_1.default.gray(repoRoot));
+    console.log(chalk_1.default.cyan("\n📈 Recent Commits:\n"));
+    const commits = git_history_js_1.gitHistory.getRecentCommits(10);
+    commits.slice(0, 5).forEach((commit, i) => {
+        const date = new Date(commit.date).toLocaleDateString();
+        console.log(chalk_1.default.green(`${i + 1}. ${commit.author}`) + chalk_1.default.gray(` (${date})`));
+        console.log(chalk_1.default.white(`   ${commit.message.substring(0, 70)}${commit.message.length > 70 ? '...' : ''}`));
+        console.log(chalk_1.default.gray(`   ${commit.filesChanged.length} files changed`));
+        console.log();
+    });
+});
 program.parse();

package/dist/commands/ingest.js

@@ -2,14 +2,19 @@ import fs from "fs";
 import path from "path";
 import { scanDir } from "../lib/scanner.js";
 import { chunkCode } from "../lib/chunker.js";
-import { saveToDB } from "../lib/database.js";
+import { saveToDB, saveAuthorToDB } from "../lib/database.js";
 import { localEmbeddings } from "../lib/local-embeddings.js";
-export async function ingest(rootDir, projectName, silent = false) {
+import { gitHistory } from "../lib/git-history.js";
+export async function ingest(rootDir, projectName, silent = false, includeGitHistory = true) {
     if (!silent)
         console.log("Starting ingestion...");
     const files = await scanDir(rootDir);
     if (!silent)
         console.log(`Found ${files.length} files to process`);
+    const isGitRepo = gitHistory.isRepository();
+    if (isGitRepo && includeGitHistory && !silent) {
+        console.log(`Git repository detected - enriching with history data`);
+    }
     const allChunks = [];
     for (const filePath of files) {
         try {
@@ -31,10 +36,38 @@ export async function ingest(rootDir, projectName, silent = false) {
         console.log(`Saving to database...`);
     const BATCH_SIZE = 50;
     let processedCount = 0;
+    const fileGitData = new Map();
+    if (isGitRepo && includeGitHistory) {
+        for (const { filePath } of allChunks) {
+            if (!fileGitData.has(filePath)) {
+                const history = gitHistory.getFileHistory(filePath, 100);
+                fileGitData.set(filePath, history);
+            }
+        }
+    }
     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);
+            let gitMetadata = {};
+            if (isGitRepo && includeGitHistory) {
+                const history = fileGitData.get(filePath);
+                if (history && history.commits.length > 0) {
+                    const lastCommit = history.commits[0];
+                    const primaryAuthor = history.primaryAuthors[0];
+                    gitMetadata = {
+                        lastCommitHash: lastCommit.hash,
+                        lastCommitAuthor: lastCommit.author,
+                        lastCommitEmail: lastCommit.email,
+                        lastCommitDate: lastCommit.date,
+                        lastCommitMessage: lastCommit.message,
+                        totalCommits: history.totalCommits,
+                        primaryAuthor: primaryAuthor?.author,
+                        primaryAuthorEmail: primaryAuthor?.email,
+                        fileOwnerCommits: primaryAuthor?.commitCount,
+                    };
+                }
+            }
             await saveToDB({
                 content,
                 embedding,
@@ -44,6 +77,7 @@ export async function ingest(rootDir, projectName, silent = false) {
                 functionName: chunk.functionName,
                 lineStart: chunk.lineStart,
                 lineEnd: chunk.lineEnd,
+                ...gitMetadata,
             });
         }));
         processedCount += batch.length;
@@ -51,6 +85,34 @@ export async function ingest(rootDir, projectName, silent = false) {
             console.log(`Saved ${processedCount}/${allChunks.length} chunks...`);
         }
     }
-    if (!silent)
+    if (isGitRepo && includeGitHistory && !silent) {
+        console.log("Computing author statistics...");
+        const authorStats = gitHistory.getAuthorStats();
+        for (const stats of authorStats) {
+            const ownedFiles = [];
+            fileGitData.forEach((history, filePath) => {
+                if (history?.primaryAuthors[0]?.email === stats.email) {
+                    ownedFiles.push(path.relative(gitHistory.getRepositoryRoot(), filePath));
+                }
+            });
+            await saveAuthorToDB({
+                projectName,
+                author: stats.author,
+                email: stats.email,
+                totalCommits: stats.totalCommits,
+                linesAdded: stats.linesAdded,
+                linesRemoved: stats.linesRemoved,
+                recentActivity: stats.recentActivity,
+                filesOwned: ownedFiles,
+            });
+        }
+        if (!silent)
+            console.log(`Stored stats for ${authorStats.length} contributors`);
+    }
+    if (!silent) {
         console.log(`Done! Processed ${processedCount} chunks from ${files.length} files.`);
+        if (isGitRepo && includeGitHistory) {
+            console.log(`Git history enrichment complete`);
+        }
+    }
 }

package/dist/commands/search.js

@@ -2,21 +2,48 @@
 import { client } from "../lib/database.js";
 import { localEmbeddings } from "../lib/local-embeddings.js";
 import { getAIClient } from "../lib/ai-provider.js";
-export async function search(query, projectName, provider, model) {
+export async function search(query, projectName, provider, model, options = {}) {
+    const { boostRecent = false, boostFrequent = false, filterAuthor, recentDays = 30, } = options;
+    const whereClause = { projectName };
+    if (filterAuthor) {
+        whereClause.OR = [
+            { lastCommitEmail: filterAuthor },
+            { primaryAuthorEmail: filterAuthor },
+        ];
+    }
     const snippets = await client.codeSnippet.findMany({
-        where: { projectName },
+        where: whereClause,
     });
     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: localEmbeddings.cosineSimilarity(queryVector, snippet.embedding),
-    }))
+        .map(snippet => {
+        let score = localEmbeddings.cosineSimilarity(queryVector, snippet.embedding);
+        if (boostRecent && snippet.lastCommitDate) {
+            const daysSinceCommit = (Date.now() - snippet.lastCommitDate.getTime()) / (1000 * 60 * 60 * 24);
+            if (daysSinceCommit <= recentDays) {
+                const recencyBoost = 1 + (0.2 * (1 - daysSinceCommit / recentDays));
+                score *= recencyBoost;
+            }
+        }
+        if (boostFrequent && snippet.totalCommits) {
+            const commitBoost = 1 + (Math.min(snippet.totalCommits, 50) / 50) * 0.15;
+            score *= commitBoost;
+        }
+        return {
+            id: snippet.id,
+            content: snippet.content,
+            filePath: snippet.filePath,
+            functionName: snippet.functionName,
+            score,
+            lastCommitAuthor: snippet.lastCommitAuthor,
+            lastCommitDate: snippet.lastCommitDate,
+            lastCommitMessage: snippet.lastCommitMessage,
+            totalCommits: snippet.totalCommits,
+            primaryAuthor: snippet.primaryAuthor,
+        };
+    })
         .sort((a, b) => b.score - a.score);
     const seenFiles = new Set();
     const uniqueResults = ranked.filter(item => {
@@ -26,9 +53,86 @@ export async function search(query, projectName, provider, model) {
         return true;
     }).slice(0, 5);
     const context = uniqueResults
-        .map((r, i) => `[${i + 1}] ${r.filePath}${r.functionName ? ` (${r.functionName})` : ""}\n${r.content}`)
+        .map((r, i) => {
+        let entry = `[${i + 1}] ${r.filePath}${r.functionName ? ` (${r.functionName})` : ""}`;
+        if (r.lastCommitAuthor || r.primaryAuthor) {
+            const author = r.primaryAuthor || r.lastCommitAuthor;
+            entry += `\nPrimary Author: ${author}`;
+            if (r.totalCommits) {
+                entry += ` (${r.totalCommits} commits)`;
+            }
+        }
+        if (r.lastCommitDate) {
+            const daysAgo = Math.floor((Date.now() - r.lastCommitDate.getTime()) / (1000 * 60 * 60 * 24));
+            entry += `\nLast Modified: ${daysAgo} days ago`;
+            if (r.lastCommitMessage) {
+                entry += `\nLast Commit: "${r.lastCommitMessage.substring(0, 60)}${r.lastCommitMessage.length > 60 ? '...' : ''}"`;
+            }
+        }
+        entry += `\n\n${r.content}`;
+        return entry;
+    })
         .join("\n\n---\n\n");
     const aiClient = getAIClient(provider, model);
-    const answer = await aiClient.generateAnswer(query, context);
+    const enhancedPrompt = query +
+        "\n\nNote: Code snippets include git history metadata (authors, commit counts, last modified dates). " +
+        "Use this information to provide context about code ownership and recency when relevant.";
+    const answer = await aiClient.generateAnswer(enhancedPrompt, context);
     return { answer, sources: uniqueResults };
 }
+export async function searchByAuthor(authorEmail, projectName) {
+    const snippets = await client.codeSnippet.findMany({
+        where: {
+            projectName,
+            OR: [
+                { lastCommitEmail: authorEmail },
+                { primaryAuthorEmail: authorEmail },
+            ],
+        },
+        select: {
+            filePath: true,
+            functionName: true,
+            totalCommits: true,
+            lastCommitDate: true,
+        },
+        orderBy: {
+            totalCommits: "desc",
+        },
+    });
+    const fileMap = new Map();
+    snippets.forEach(s => {
+        if (!fileMap.has(s.filePath)) {
+            fileMap.set(s.filePath, s);
+        }
+    });
+    return Array.from(fileMap.values());
+}
+export async function getRecentActivity(projectName, days = 7) {
+    const since = new Date();
+    since.setDate(since.getDate() - days);
+    const snippets = await client.codeSnippet.findMany({
+        where: {
+            projectName,
+            lastCommitDate: {
+                gte: since,
+            },
+        },
+        select: {
+            filePath: true,
+            lastCommitAuthor: true,
+            lastCommitDate: true,
+            lastCommitMessage: true,
+        },
+        orderBy: {
+            lastCommitDate: "desc",
+        },
+        take: 20,
+    });
+    const fileMap = new Map();
+    snippets.forEach(s => {
+        if (!fileMap.has(s.filePath)) {
+            fileMap.set(s.filePath, s);
+        }
+    });
+    return Array.from(fileMap.values());
+}

package/dist/lib/context-generator.js

@@ -1,9 +1,11 @@
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { search } from "../commands/search.js";
+import { search, getRecentActivity } from "../commands/search.js";
+import { getProjectAuthors } from "../lib/database.js";
+import { gitHistory } from "../lib/git-history.js";
 export async function generateCodebaseDoc(projectName) {
-    console.log("🔍 Analyzing your codebase...\n");
+    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?",
@@ -15,8 +17,24 @@ export async function generateCodebaseDoc(projectName) {
     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`;
+    if (gitHistory.isRepository()) {
+        doc += `## Repository Information\n\n`;
+        const currentBranch = gitHistory.getCurrentBranch();
+        if (currentBranch) {
+            doc += `**Current Branch:** ${currentBranch}\n\n`;
+        }
+        const recentCommits = gitHistory.getRecentCommits(10);
+        if (recentCommits.length > 0) {
+            doc += `**Recent Activity:**\n`;
+            recentCommits.slice(0, 5).forEach(commit => {
+                const date = new Date(commit.date).toLocaleDateString();
+                doc += `- ${date} - ${commit.author}: ${commit.message.substring(0, 60)}${commit.message.length > 60 ? '...' : ''}\n`;
+            });
+            doc += `\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`;
@@ -28,12 +46,15 @@ export async function generateCodebaseDoc(projectName) {
             doc += `## ${query}\n\n`;
             doc += `${answer}\n\n`;
             if (sources.length > 0) {
-                doc += `### 📁 Key Files\n\n`;
+                doc += `### Key Files\n\n`;
                 sources.slice(0, 5).forEach(s => {
                     doc += `- \`${s.filePath}\``;
                     if (s.functionName) {
                         doc += ` - ${s.functionName}`;
                     }
+                    if (s.primaryAuthor) {
+                        doc += ` (maintained by ${s.primaryAuthor})`;
+                    }
                     doc += `\n`;
                 });
                 doc += `\n`;
@@ -44,7 +65,28 @@ export async function generateCodebaseDoc(projectName) {
             console.error(`Error analyzing: ${query}`);
         }
     }
-    doc += `## 📂 Project Structure\n\n`;
+    if (gitHistory.isRepository()) {
+        doc += `## Contributors\n\n`;
+        const authors = await getProjectAuthors(projectName);
+        if (authors.length > 0) {
+            doc += `This project has ${authors.length} contributor${authors.length > 1 ? 's' : ''}:\n\n`;
+            authors.slice(0, 10).forEach((author, i) => {
+                doc += `${i + 1}. **${author.author}** (${author.email})\n`;
+                doc += `   - ${author.totalCommits} commits\n`;
+                doc += `   - +${author.linesAdded} / -${author.linesRemoved} lines\n`;
+                if (author.recentActivity) {
+                    const daysAgo = Math.floor((Date.now() - author.recentActivity.getTime()) / (1000 * 60 * 60 * 24));
+                    doc += `   - Last active ${daysAgo} days ago\n`;
+                }
+                if (author.filesOwned.length > 0) {
+                    doc += `   - Primary owner of ${author.filesOwned.length} files\n`;
+                }
+                doc += `\n`;
+            });
+            doc += `---\n\n`;
+        }
+    }
+    doc += `## Project Structure\n\n`;
     doc += '```\n';
     doc += await getProjectStructure(process.cwd());
     doc += '```\n\n';
@@ -59,7 +101,7 @@ export async function generateCodebaseDoc(projectName) {
     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 += `## Updating This Document\n\n`;
     doc += `This documentation is auto-generated. To regenerate:\n\n`;
     doc += '```bash\n';
     doc += 'quack --docs\n';
@@ -81,6 +123,34 @@ export async function generateContextFiles(projectName) {
     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";
+    if (gitHistory.isRepository()) {
+        baseContext += `## Git Repository Info\n\n`;
+        const branch = gitHistory.getCurrentBranch();
+        if (branch) {
+            baseContext += `**Branch:** ${branch}\n\n`;
+        }
+        const recentActivity = await getRecentActivity(projectName, 7);
+        if (recentActivity.length > 0) {
+            baseContext += `**Recent Changes (Last 7 days):**\n\n`;
+            recentActivity.slice(0, 5).forEach(item => {
+                const daysAgo = Math.floor((Date.now() - item.lastCommitDate.getTime()) / (1000 * 60 * 60 * 24));
+                baseContext += `- ${item.filePath}\n`;
+                baseContext += `  - Modified by ${item.lastCommitAuthor} ${daysAgo} days ago\n`;
+                if (item.lastCommitMessage) {
+                    baseContext += `  - "${item.lastCommitMessage.substring(0, 60)}${item.lastCommitMessage.length > 60 ? '...' : ''}"\n`;
+                }
+            });
+            baseContext += `\n`;
+        }
+        const authors = await getProjectAuthors(projectName);
+        if (authors.length > 0) {
+            baseContext += `**Top Contributors:**\n\n`;
+            authors.slice(0, 5).forEach(author => {
+                baseContext += `- ${author.author} (${author.totalCommits} commits, owns ${author.filesOwned.length} files)\n`;
+            });
+            baseContext += `\n`;
+        }
+    }
     baseContext += "---\n\n";
     for (const query of queries) {
         try {
@@ -89,7 +159,11 @@ export async function generateContextFiles(projectName) {
             if (sources.length > 0) {
                 baseContext += "**Key files:**\n";
                 sources.slice(0, 3).forEach(s => {
-                    baseContext += `- ${s.filePath}\n`;
+                    baseContext += `- ${s.filePath}`;
+                    if (s.primaryAuthor) {
+                        baseContext += ` (${s.primaryAuthor})`;
+                    }
+                    baseContext += `\n`;
                 });
                 baseContext += "\n";
             }
@@ -100,12 +174,28 @@ export async function generateContextFiles(projectName) {
     }
     baseContext += "---\n\n## Project Structure\n\n";
     baseContext += await getProjectStructure(process.cwd());
+    if (gitHistory.isRepository()) {
+        const authors = await getProjectAuthors(projectName);
+        if (authors.length > 0) {
+            baseContext += "\n---\n\n## Code Ownership & Expertise\n\n";
+            baseContext += "When making changes, consider consulting these experts:\n\n";
+            for (const author of authors.slice(0, 5)) {
+                if (author.filesOwned.length > 0) {
+                    baseContext += `**${author.author}** - Expert in:\n`;
+                    author.filesOwned.slice(0, 5).forEach(file => {
+                        baseContext += `- ${file}\n`;
+                    });
+                    baseContext += `\n`;
+                }
+            }
+        }
+    }
     await generateCursorRules(baseContext);
     await generateWindsurfContext(baseContext);
     await generateClineContext(baseContext);
     await generateContinueContext(baseContext);
     await generateAiderContext(baseContext);
-    console.log("\n✅ Context files generated for:");
+    console.log("\n Context files generated for:");
     console.log("  - Cursor (.cursorrules)");
     console.log("  - Windsurf (.windsurfrules)");
     console.log("  - Cline (.clinerules)");
@@ -138,11 +228,9 @@ async function generateAiderContext(context) {
     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
 `;
@@ -166,6 +254,12 @@ export async function updateGlobalContext(projectName) {
         topFiles: sources.slice(0, 5).map(s => s.filePath),
         lastUpdated: new Date().toISOString(),
     };
+    if (gitHistory.isRepository()) {
+        const branch = gitHistory.getCurrentBranch();
+        const authors = await getProjectAuthors(projectName);
+        contexts[projectName].gitBranch = branch;
+        contexts[projectName].contributors = authors.length;
+    }
     fs.writeFileSync(contextPath, JSON.stringify(contexts, null, 2), "utf-8");
 }
 export function watchAndUpdateContext(projectName) {
@@ -180,7 +274,7 @@ export function watchAndUpdateContext(projectName) {
             await generateContextFiles(projectName);
         }, 5000);
     });
-    console.log("👀 Watching for file changes...");
+    console.log("Watching for file changes...");
 }
 async function getProjectStructure(dir, prefix = "", maxDepth = 3, currentDepth = 0) {
     if (currentDepth >= maxDepth)

package/dist/lib/database.js

@@ -1,41 +1,109 @@
 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,
+export async function saveToDB(data) {
+    await client.codeSnippet.create({
+        data: {
+            content: data.content,
+            embedding: data.embedding,
+            filePath: data.filePath,
+            projectName: data.projectName,
+            language: data.language,
+            functionName: data.functionName,
+            lineStart: data.lineStart,
+            lineEnd: data.lineEnd,
+            lastCommitHash: data.lastCommitHash,
+            lastCommitAuthor: data.lastCommitAuthor,
+            lastCommitEmail: data.lastCommitEmail,
+            lastCommitDate: data.lastCommitDate,
+            lastCommitMessage: data.lastCommitMessage,
+            totalCommits: data.totalCommits,
+            primaryAuthor: data.primaryAuthor,
+            primaryAuthorEmail: data.primaryAuthorEmail,
+            fileOwnerCommits: data.fileOwnerCommits,
+        },
+    });
+}
+export async function saveAuthorToDB(data) {
+    await client.gitAuthor.upsert({
+        where: {
+            projectName_email: {
+                projectName: data.projectName,
+                email: data.email,
             },
-        });
-        return result;
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            console.error(`Error saving to DB: ${e.message}`);
+        },
+        create: data,
+        update: {
+            author: data.author,
+            totalCommits: data.totalCommits,
+            linesAdded: data.linesAdded,
+            linesRemoved: data.linesRemoved,
+            recentActivity: data.recentActivity,
+            filesOwned: data.filesOwned,
+        },
+    });
+}
+export async function clearProject(projectName) {
+    await client.codeSnippet.deleteMany({
+        where: { projectName },
+    });
+    await client.gitAuthor.deleteMany({
+        where: { projectName },
+    });
+}
+export async function getProjectAuthors(projectName) {
+    return await client.gitAuthor.findMany({
+        where: { projectName },
+        orderBy: { totalCommits: "desc" },
+    });
+}
+export async function getAuthorFiles(projectName, authorEmail) {
+    const snippets = await client.codeSnippet.findMany({
+        where: {
+            projectName,
+            primaryAuthorEmail: authorEmail,
+        },
+        select: {
+            filePath: true,
+            functionName: true,
+            totalCommits: true,
+        },
+        orderBy: {
+            totalCommits: "desc",
+        },
+    });
+    const fileMap = new Map();
+    snippets.forEach(s => {
+        if (!fileMap.has(s.filePath)) {
+            fileMap.set(s.filePath, s);
         }
-        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);
+    });
+    return Array.from(fileMap.values());
+}
+export async function getRecentlyModifiedFiles(projectName, days = 7) {
+    const since = new Date();
+    since.setDate(since.getDate() - days);
+    const snippets = await client.codeSnippet.findMany({
+        where: {
+            projectName,
+            lastCommitDate: {
+                gte: since,
+            },
+        },
+        select: {
+            filePath: true,
+            lastCommitAuthor: true,
+            lastCommitDate: true,
+            lastCommitMessage: true,
+        },
+        orderBy: {
+            lastCommitDate: "desc",
+        },
+    });
+    const fileMap = new Map();
+    snippets.forEach(s => {
+        if (!fileMap.has(s.filePath)) {
+            fileMap.set(s.filePath, s);
         }
-        throw e;
-    }
-};
+    });
+    return Array.from(fileMap.values());
+}

package/dist/lib/git-history.js

@@ -0,0 +1,312 @@
+import { execSync } from "child_process";
+import path from "path";
+import fs from "fs";
+export class GitHistory {
+    repoRoot;
+    isGitRepo;
+    constructor(projectPath = process.cwd()) {
+        this.repoRoot = this.findGitRoot(projectPath);
+        this.isGitRepo = this.repoRoot !== "";
+    }
+    findGitRoot(startPath) {
+        try {
+            const result = execSync("git rev-parse --show-toplevel", {
+                cwd: startPath,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            return result;
+        }
+        catch {
+            return "";
+        }
+    }
+    isRepository() {
+        return this.isGitRepo;
+    }
+    getFileHistory(filePath, limit = 10) {
+        if (!this.isGitRepo)
+            return null;
+        try {
+            const relativePath = path.relative(this.repoRoot, filePath);
+            // Get commit history for file
+            const logOutput = execSync(`git log --follow --format="%H|%an|%ae|%aI|%s" -n ${limit} -- "${relativePath}"`, {
+                cwd: this.repoRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            if (!logOutput)
+                return null;
+            const commits = logOutput.split("\n").map(line => {
+                const [hash, author, email, date, ...messageParts] = line.split("|");
+                return {
+                    hash,
+                    author,
+                    email,
+                    date: new Date(date),
+                    message: messageParts.join("|"),
+                    filesChanged: [relativePath],
+                };
+            });
+            // Get author statistics
+            const authorMap = new Map();
+            commits.forEach(commit => {
+                const key = commit.email;
+                if (authorMap.has(key)) {
+                    authorMap.get(key).commitCount++;
+                }
+                else {
+                    authorMap.set(key, {
+                        author: commit.author,
+                        email: commit.email,
+                        commitCount: 1,
+                    });
+                }
+            });
+            const primaryAuthors = Array.from(authorMap.values())
+                .sort((a, b) => b.commitCount - a.commitCount);
+            return {
+                filePath: relativePath,
+                commits,
+                lastModified: commits[0]?.date || new Date(),
+                lastAuthor: commits[0]?.author || "Unknown",
+                totalCommits: commits.length,
+                primaryAuthors,
+            };
+        }
+        catch (error) {
+            console.error(`Error getting history for ${filePath}:`, error);
+            return null;
+        }
+    }
+    getBlameInfo(filePath) {
+        if (!this.isGitRepo)
+            return null;
+        try {
+            const relativePath = path.relative(this.repoRoot, filePath);
+            if (!fs.existsSync(filePath))
+                return null;
+            const blameOutput = execSync(`git blame --line-porcelain "${relativePath}"`, {
+                cwd: this.repoRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            const lines = blameOutput.split("\n");
+            const blameInfo = [];
+            let currentInfo = {};
+            let lineNumber = 0;
+            for (const line of lines) {
+                if (line.match(/^[0-9a-f]{40}/)) {
+                    if (currentInfo.commitHash) {
+                        blameInfo.push(currentInfo);
+                    }
+                    currentInfo = {
+                        commitHash: line.split(" ")[0],
+                        lineNumber: ++lineNumber,
+                    };
+                }
+                else if (line.startsWith("author ")) {
+                    currentInfo.author = line.substring(7);
+                }
+                else if (line.startsWith("author-mail ")) {
+                    currentInfo.email = line.substring(12).replace(/[<>]/g, "");
+                }
+                else if (line.startsWith("author-time ")) {
+                    currentInfo.date = new Date(parseInt(line.substring(12)) * 1000);
+                }
+            }
+            if (currentInfo.commitHash) {
+                blameInfo.push(currentInfo);
+            }
+            return blameInfo;
+        }
+        catch (error) {
+            console.error(`Error getting blame for ${filePath}:`, error);
+            return null;
+        }
+    }
+    getRecentCommits(limit = 50) {
+        if (!this.isGitRepo)
+            return [];
+        try {
+            const logOutput = execSync(`git log --format="%H|%an|%ae|%aI|%s" --name-only -n ${limit}`, {
+                cwd: this.repoRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            const commits = [];
+            const blocks = logOutput.split("\n\n");
+            for (const block of blocks) {
+                const lines = block.split("\n");
+                if (lines.length < 1)
+                    continue;
+                const [hash, author, email, date, ...messageParts] = lines[0].split("|");
+                const filesChanged = lines.slice(1).filter(f => f.trim());
+                commits.push({
+                    hash,
+                    author,
+                    email,
+                    date: new Date(date),
+                    message: messageParts.join("|"),
+                    filesChanged,
+                });
+            }
+            return commits;
+        }
+        catch (error) {
+            console.error("Error getting recent commits:", error);
+            return [];
+        }
+    }
+    getAuthorStats() {
+        if (!this.isGitRepo)
+            return [];
+        try {
+            // Get basic author stats
+            const authorOutput = execSync(`git shortlog -sne --all`, {
+                cwd: this.repoRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            const authorMap = new Map();
+            authorOutput.split("\n").forEach(line => {
+                const match = line.match(/^\s*(\d+)\s+(.+?)\s+<(.+?)>/);
+                if (match) {
+                    const [, commits, author, email] = match;
+                    authorMap.set(email, {
+                        author,
+                        email,
+                        totalCommits: parseInt(commits),
+                        filesOwned: [],
+                        recentActivity: new Date(0),
+                        linesAdded: 0,
+                        linesRemoved: 0,
+                    });
+                }
+            });
+            // Get recent activity for each author
+            authorMap.forEach((stats, email) => {
+                try {
+                    const lastCommit = execSync(`git log --author="${email}" -1 --format="%aI"`, {
+                        cwd: this.repoRoot,
+                        encoding: "utf-8",
+                        stdio: ["pipe", "pipe", "pipe"],
+                    }).trim();
+                    if (lastCommit) {
+                        stats.recentActivity = new Date(lastCommit);
+                    }
+                    // Get line changes
+                    const lineStats = execSync(`git log --author="${email}" --pretty=tformat: --numstat`, {
+                        cwd: this.repoRoot,
+                        encoding: "utf-8",
+                        stdio: ["pipe", "pipe", "pipe"],
+                    }).trim();
+                    lineStats.split("\n").forEach(line => {
+                        const [added, removed] = line.split("\t").map(n => parseInt(n) || 0);
+                        stats.linesAdded += added;
+                        stats.linesRemoved += removed;
+                    });
+                }
+                catch {
+                    // Ignore errors for individual authors
+                }
+            });
+            return Array.from(authorMap.values())
+                .sort((a, b) => b.totalCommits - a.totalCommits);
+        }
+        catch (error) {
+            console.error("Error getting author stats:", error);
+            return [];
+        }
+    }
+    getRecentlyChangedFiles(days = 7) {
+        if (!this.isGitRepo)
+            return [];
+        try {
+            const since = new Date();
+            since.setDate(since.getDate() - days);
+            const sinceStr = since.toISOString().split("T")[0];
+            const output = execSync(`git log --since="${sinceStr}" --format="%aI|%an" --name-only`, {
+                cwd: this.repoRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            const fileMap = new Map();
+            const blocks = output.split("\n\n");
+            for (const block of blocks) {
+                const lines = block.split("\n");
+                if (lines.length < 1)
+                    continue;
+                const [dateStr, author] = lines[0].split("|");
+                const date = new Date(dateStr);
+                const files = lines.slice(1).filter(f => f.trim());
+                files.forEach(file => {
+                    if (!fileMap.has(file) || fileMap.get(file).lastModified < date) {
+                        fileMap.set(file, { lastModified: date, author });
+                    }
+                });
+            }
+            return Array.from(fileMap.entries())
+                .map(([filePath, info]) => ({ filePath, ...info }))
+                .sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+        }
+        catch (error) {
+            console.error("Error getting recently changed files:", error);
+            return [];
+        }
+    }
+    getFileOwner(filePath) {
+        const history = this.getFileHistory(filePath, 100);
+        if (!history || history.primaryAuthors.length === 0)
+            return null;
+        return history.primaryAuthors[0];
+    }
+    getCommitMessage(commitHash) {
+        if (!this.isGitRepo)
+            return null;
+        try {
+            return execSync(`git log --format=%B -n 1 ${commitHash}`, {
+                cwd: this.repoRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    hasUncommittedChanges(filePath) {
+        if (!this.isGitRepo)
+            return false;
+        try {
+            const relativePath = path.relative(this.repoRoot, filePath);
+            const status = execSync(`git status --porcelain "${relativePath}"`, {
+                cwd: this.repoRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            return status.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    getCurrentBranch() {
+        if (!this.isGitRepo)
+            return null;
+        try {
+            return execSync(`git rev-parse --abbrev-ref HEAD`, {
+                cwd: this.repoRoot,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    getRepositoryRoot() {
+        return this.repoRoot;
+    }
+}
+export const gitHistory = new GitHistory();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quackstack",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "description": "Your cracked unpaid intern for all things codebase related! AI-powered codebase search and Q&A.",
   "type": "module",
   "main": "dist/cli.cjs",

package/prisma/schema.prisma

@@ -1,9 +1,6 @@
 // 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"
 }
@@ -23,8 +20,40 @@ model codeSnippet {
   functionName String?
   lineStart    Int?     
   lineEnd      Int?     
+  
+  lastCommitHash    String?
+  lastCommitAuthor  String?
+  lastCommitEmail   String?
+  lastCommitDate    DateTime?
+  lastCommitMessage String?
+  totalCommits      Int?       @default(0)
+  primaryAuthor     String?
+  primaryAuthorEmail String?
+  fileOwnerCommits  Int?       @default(0)
+  
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([projectName])
+  @@index([lastCommitDate])
+  @@index([primaryAuthor])
+}
+
+model gitAuthor {
+  id              Int      @id @default(autoincrement())
+  projectName     String
+  author          String
+  email           String
+  totalCommits    Int      @default(0)
+  linesAdded      Int      @default(0)
+  linesRemoved    Int      @default(0)
+  recentActivity  DateTime?
+  filesOwned      String[] 
+  
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
+  @@unique([projectName, email])
   @@index([projectName])
+  @@index([recentActivity])
 }