devguard 0.1.0 → 0.2.0

package/dist/utils/collision.d.ts

@@ -0,0 +1,22 @@
+export interface AgentFileMap {
+    agent_id: string;
+    name: string;
+    status: string;
+    files: string[];
+}
+export interface Collision {
+    file: string;
+    agents: string[];
+}
+/**
+ * Parse all agent files and extract their file lists.
+ */
+export declare function getAgentFileMaps(projectPath: string): AgentFileMap[];
+/**
+ * Find files claimed by more than one active agent.
+ */
+export declare function detectCollisions(projectPath: string): Collision[];
+/**
+ * Check if a specific set of files would collide with any active agent.
+ */
+export declare function checkFilesForCollisions(projectPath: string, files: string[], excludeAgentId?: string): Collision[];

package/dist/utils/collision.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAgentFileMaps = getAgentFileMaps;
+exports.detectCollisions = detectCollisions;
+exports.checkFilesForCollisions = checkFilesForCollisions;
+const storage = __importStar(require("./storage.js"));
+/**
+ * Parse all agent files and extract their file lists.
+ */
+function getAgentFileMaps(projectPath) {
+    const agentFiles = storage.listAgentFiles(projectPath);
+    return agentFiles.map((f) => {
+        const agentId = f.replace(/\.md$/, "");
+        const content = storage.readAgentFile(projectPath, agentId) ?? "";
+        const statusMatch = content.match(/^status:\s*(.+)$/m);
+        const nameMatch = content.match(/^name:\s*(.+)$/m);
+        const filesSection = content.match(/^files_touching:\n((?:\s+-\s+.+\n?)*)/m);
+        const files = [];
+        if (filesSection?.[1]) {
+            const lines = filesSection[1].split("\n");
+            for (const line of lines) {
+                const match = line.match(/^\s+-\s+(.+)/);
+                if (match)
+                    files.push(match[1].trim());
+            }
+        }
+        return {
+            agent_id: agentId,
+            name: nameMatch?.[1] ?? "",
+            status: statusMatch?.[1] ?? "unknown",
+            files,
+        };
+    });
+}
+/**
+ * Find files claimed by more than one active agent.
+ */
+function detectCollisions(projectPath) {
+    const agents = getAgentFileMaps(projectPath).filter((a) => a.status === "active");
+    const fileToAgents = new Map();
+    for (const agent of agents) {
+        for (const file of agent.files) {
+            const existing = fileToAgents.get(file) ?? [];
+            existing.push(agent.name || agent.agent_id);
+            fileToAgents.set(file, existing);
+        }
+    }
+    const collisions = [];
+    for (const [file, agents] of fileToAgents) {
+        if (agents.length > 1) {
+            collisions.push({ file, agents });
+        }
+    }
+    return collisions;
+}
+/**
+ * Check if a specific set of files would collide with any active agent.
+ */
+function checkFilesForCollisions(projectPath, files, excludeAgentId) {
+    const agents = getAgentFileMaps(projectPath).filter((a) => a.status === "active" && a.agent_id !== excludeAgentId);
+    const collisions = [];
+    for (const file of files) {
+        const claimants = agents
+            .filter((a) => a.files.includes(file))
+            .map((a) => a.name || a.agent_id);
+        if (claimants.length > 0) {
+            collisions.push({ file, agents: claimants });
+        }
+    }
+    return collisions;
+}

package/dist/utils/git.d.ts

@@ -3,4 +3,29 @@ export declare function getBranch(cwd: string): string;
 export declare function getStatus(cwd: string): string;
 export declare function getRecentCommits(cwd: string, count?: number): string;
 export declare function getDiffSummary(cwd: string): string;
+export declare function getLocalBranches(cwd: string): string[];
+export declare function getBranchLastCommit(cwd: string, branch: string): string;
+export declare function getBranchCommitCount(cwd: string, branch: string, base: string): number;
+export interface CommitNode {
+    shortHash: string;
+    message: string;
+    author: string;
+    date: string;
+    timestamp: number;
+    files?: string[];
+    insertions?: number;
+    deletions?: number;
+    body?: string;
+}
+export declare function getBranchCommits(cwd: string, branch: string, limit?: number): CommitNode[];
+export declare function getBehindCount(cwd: string, branch: string, base: string): number;
+export declare function getFilesChangedCount(cwd: string, branch: string, base: string): number;
+export declare function getCommitFiles(cwd: string, hash: string): string[];
+export declare function getCommitStats(cwd: string, hash: string): {
+    insertions: number;
+    deletions: number;
+};
+export declare function getCommitBody(cwd: string, hash: string): string;
+export declare function getCommitDiffSummary(cwd: string, hash: string): string;
+export declare function getHeadCommitHash(cwd: string): string;
 export declare function getDiffFull(cwd: string): string;

package/dist/utils/git.js

@@ -5,6 +5,17 @@ exports.getBranch = getBranch;
 exports.getStatus = getStatus;
 exports.getRecentCommits = getRecentCommits;
 exports.getDiffSummary = getDiffSummary;
+exports.getLocalBranches = getLocalBranches;
+exports.getBranchLastCommit = getBranchLastCommit;
+exports.getBranchCommitCount = getBranchCommitCount;
+exports.getBranchCommits = getBranchCommits;
+exports.getBehindCount = getBehindCount;
+exports.getFilesChangedCount = getFilesChangedCount;
+exports.getCommitFiles = getCommitFiles;
+exports.getCommitStats = getCommitStats;
+exports.getCommitBody = getCommitBody;
+exports.getCommitDiffSummary = getCommitDiffSummary;
+exports.getHeadCommitHash = getHeadCommitHash;
 exports.getDiffFull = getDiffFull;
 const child_process_1 = require("child_process");
 function run(cmd, cwd) {
@@ -37,6 +48,69 @@ function getDiffSummary(cwd) {
         parts.push(`Unstaged:\n${unstaged}`);
     return parts.join("\n\n") || "No changes";
 }
+function getLocalBranches(cwd) {
+    const output = run("git branch --format='%(refname:short)'", cwd);
+    if (!output)
+        return [];
+    return output.split("\n").map((b) => b.trim().replace(/^'|'$/g, "")).filter(Boolean);
+}
+function getBranchLastCommit(cwd, branch) {
+    return run(`git log -1 --format="%s" "${branch}"`, cwd);
+}
+function getBranchCommitCount(cwd, branch, base) {
+    const output = run(`git rev-list --count "${base}..${branch}"`, cwd);
+    return parseInt(output, 10) || 0;
+}
+function getBranchCommits(cwd, branch, limit = 15) {
+    const sep = "|||";
+    const output = run(`git log "${branch}" --format="%h${sep}%s${sep}%an${sep}%ai${sep}%at" -n ${limit}`, cwd);
+    if (!output)
+        return [];
+    return output.split("\n").filter(Boolean).map(line => {
+        const parts = line.split(sep);
+        return {
+            shortHash: parts[0] || "",
+            message: parts[1] || "",
+            author: parts[2] || "",
+            date: parts[3] || "",
+            timestamp: parseInt(parts[4]) || 0,
+        };
+    });
+}
+function getBehindCount(cwd, branch, base) {
+    const output = run(`git rev-list --count "${branch}..${base}"`, cwd);
+    return parseInt(output, 10) || 0;
+}
+function getFilesChangedCount(cwd, branch, base) {
+    const output = run(`git diff --name-only "${base}...${branch}"`, cwd);
+    if (!output)
+        return 0;
+    return output.split("\n").filter(Boolean).length;
+}
+function getCommitFiles(cwd, hash) {
+    const output = run(`git diff-tree --no-commit-id --name-only -r "${hash}"`, cwd);
+    if (!output)
+        return [];
+    return output.split("\n").filter(Boolean);
+}
+function getCommitStats(cwd, hash) {
+    const output = run(`git diff-tree --no-commit-id --shortstat -r "${hash}"`, cwd);
+    const ins = output.match(/(\d+) insertion/);
+    const del = output.match(/(\d+) deletion/);
+    return {
+        insertions: ins ? parseInt(ins[1]) : 0,
+        deletions: del ? parseInt(del[1]) : 0,
+    };
+}
+function getCommitBody(cwd, hash) {
+    return run(`git log -1 --format="%b" "${hash}"`, cwd);
+}
+function getCommitDiffSummary(cwd, hash) {
+    return run(`git diff-tree --no-commit-id --stat -r "${hash}"`, cwd);
+}
+function getHeadCommitHash(cwd) {
+    return run("git rev-parse --short HEAD", cwd);
+}
 function getDiffFull(cwd) {
     const staged = run("git diff --cached", cwd);
     const unstaged = run("git diff", cwd);

package/dist/utils/storage.d.ts

@@ -1,3 +1,22 @@
 export declare function ensureDiaryDir(projectPath: string): string;
 export declare function writeEntry(projectPath: string, content: string): string;
 export declare function readEntries(projectPath: string, count: number): string[];
+export declare function ensureBranchesDir(projectPath: string): string;
+export declare function writeBranchEntry(projectPath: string, branch: string, content: string): string;
+export declare function readBranchEntry(projectPath: string, branch: string): string | null;
+export declare function listBranchFiles(projectPath: string): {
+    branch: string;
+    content: string;
+}[];
+export declare function extractLatestSummary(content: string): string;
+export interface DiaryEntry {
+    title: string;
+    summary: string;
+    date: string;
+    commit: string;
+    whatChanged: string[];
+    decisions: string[];
+    issues: string[];
+    nextSteps: string[];
+}
+export declare function parseDiaryEntries(content: string): DiaryEntry[];

package/dist/utils/storage.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureDiaryDir = ensureDiaryDir;
 exports.writeEntry = writeEntry;
 exports.readEntries = readEntries;
+exports.ensureBranchesDir = ensureBranchesDir;
+exports.writeBranchEntry = writeBranchEntry;
+exports.readBranchEntry = readBranchEntry;
+exports.listBranchFiles = listBranchFiles;
+exports.extractLatestSummary = extractLatestSummary;
+exports.parseDiaryEntries = parseDiaryEntries;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const DIARY_DIR = ".devguard";
@@ -41,6 +47,105 @@ function readEntries(projectPath, count) {
         .slice(0, count);
     return files.map((f) => (0, fs_1.readFileSync)((0, path_1.join)(dir, f), "utf-8"));
 }
+// --- Branch entries ---
+const BRANCHES_DIR = "branches";
+function branchesPath(projectPath) {
+    return (0, path_1.join)(projectPath, DIARY_DIR, BRANCHES_DIR);
+}
+function sanitizeBranchName(branch) {
+    return branch.replace(/\//g, "-");
+}
+function ensureBranchesDir(projectPath) {
+    const dir = branchesPath(projectPath);
+    (0, fs_1.mkdirSync)(dir, { recursive: true });
+    return dir;
+}
+function writeBranchEntry(projectPath, branch, content) {
+    const dir = ensureBranchesDir(projectPath);
+    const filename = sanitizeBranchName(branch) + ".md";
+    const filePath = (0, path_1.join)(dir, filename);
+    const now = new Date();
+    const separator = `\n\n---\n\n<!-- ${formatDate(now)} ${formatTime(now)} -->\n\n`;
+    if ((0, fs_1.existsSync)(filePath)) {
+        (0, fs_1.appendFileSync)(filePath, separator + content, "utf-8");
+    }
+    else {
+        const header = `# Branch: ${branch}\n\n`;
+        (0, fs_1.writeFileSync)(filePath, header + content, "utf-8");
+    }
+    return filePath;
+}
+function readBranchEntry(projectPath, branch) {
+    const dir = branchesPath(projectPath);
+    const filename = sanitizeBranchName(branch) + ".md";
+    const filePath = (0, path_1.join)(dir, filename);
+    if (!(0, fs_1.existsSync)(filePath))
+        return null;
+    return (0, fs_1.readFileSync)(filePath, "utf-8");
+}
+function listBranchFiles(projectPath) {
+    const dir = branchesPath(projectPath);
+    if (!(0, fs_1.existsSync)(dir))
+        return [];
+    return (0, fs_1.readdirSync)(dir)
+        .filter((f) => f.endsWith(".md"))
+        .sort()
+        .map((f) => ({
+        branch: f.replace(".md", ""),
+        content: (0, fs_1.readFileSync)((0, path_1.join)(dir, f), "utf-8"),
+    }));
+}
+function extractLatestSummary(content) {
+    // Find the last "summary:" line in frontmatter
+    const summaryMatches = [...content.matchAll(/^summary:\s*"?(.+?)"?\s*$/gm)];
+    if (summaryMatches.length > 0) {
+        return summaryMatches[summaryMatches.length - 1][1];
+    }
+    // Fallback: grab the first heading after the last separator
+    const lastSep = content.lastIndexOf("---\n");
+    const tail = lastSep >= 0 ? content.slice(lastSep) : content;
+    const headingMatch = tail.match(/^#+ (.+)$/m);
+    if (headingMatch)
+        return headingMatch[1];
+    return "No summary available";
+}
+function parseDiaryEntries(content) {
+    // Split on frontmatter separators (--- blocks)
+    const blocks = content.split(/\n---\n/).filter(b => b.trim());
+    const entries = [];
+    for (const block of blocks) {
+        const summaryMatch = block.match(/^summary:\s*"?(.+?)"?\s*$/m);
+        const dateMatch = block.match(/^date:\s*(.+)$/m);
+        const commitMatch = block.match(/^commit:\s*(.+)$/m);
+        const titleMatch = block.match(/^#+ (.+)$/m);
+        if (!titleMatch && !summaryMatch)
+            continue;
+        const entry = {
+            title: titleMatch?.[1] || summaryMatch?.[1] || "",
+            summary: summaryMatch?.[1] || titleMatch?.[1] || "",
+            date: dateMatch?.[1] || "",
+            commit: commitMatch?.[1] || "",
+            whatChanged: extractSection(block, "What Changed"),
+            decisions: extractSection(block, "Decisions"),
+            issues: extractSection(block, "Issues"),
+            nextSteps: extractSection(block, "Next Steps"),
+        };
+        if (entry.title)
+            entries.push(entry);
+    }
+    return entries;
+}
+function extractSection(block, heading) {
+    const regex = new RegExp(`## ${heading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`, "m");
+    const match = block.match(regex);
+    if (!match)
+        return [];
+    const text = match[1].trim();
+    // Split by bullet points or newlines
+    const lines = text.split(/\n/).map(l => l.replace(/^[-*]\s+/, "").trim()).filter(Boolean);
+    return lines;
+}
+// --- Helpers ---
 function formatDate(date) {
     const y = date.getFullYear();
     const mo = String(date.getMonth() + 1).padStart(2, "0");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devguard",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "MCP server that auto-generates dev diary entries from git activity",
   "license": "MIT",
   "bin": {