devguard 0.1.0

package/README.md

@@ -0,0 +1,33 @@
+# devGuard
+
+MCP server that auto-generates dev diary entries from your git activity. What changed, what decisions were made, what broke, what's next — so you can pick up where you left off.
+
+## Why
+
+You vibe code for 3 hours, close your laptop, and come back the next day with no idea what you were doing. devGuard fixes that. It reads your git state and writes a diary entry automatically.
+
+## Install
+
+Add to Claude Code:
+
+```bash
+claude mcp add devguard -- npx devguard
+```
+
+That's it. On first run, devguard automatically:
+- Adds `.devguard/` to your `.gitignore`
+- Adds an auto-logging instruction to your `CLAUDE.md` (or `.cursorrules` if that exists)
+
+From then on, your AI writes diary entries on its own — after finishing a feature, after a big commit, before context gets lost. You never think about it. The diary just fills itself.
+
+## Tools
+
+| Tool | What it does |
+|------|-------------|
+| `get_context` | Reads git branch, status, recent commits, and diffs |
+| `write_entry` | Saves a diary entry to `.devguard/entries/` |
+| `read_entries` | Reads recent entries to catch you up |
+| `catch_me_up` | Morning briefing — diary entries + git state in one shot |
+| `setup` | Re-run setup manually if needed |
+
+Entries are markdown files stored locally in your project under `.devguard/`, one file per day. Multiple sessions and agents all append to the same daily file.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const get_context_js_1 = require("./tools/get-context.js");
+const write_entry_js_1 = require("./tools/write-entry.js");
+const read_entries_js_1 = require("./tools/read-entries.js");
+const catch_me_up_js_1 = require("./tools/catch-me-up.js");
+const setup_js_1 = require("./tools/setup.js");
+const auto_setup_js_1 = require("./utils/auto-setup.js");
+// Auto-setup on first run: adds .devguard/ to .gitignore
+// and auto-logging instruction to CLAUDE.md or .cursorrules
+(0, auto_setup_js_1.autoSetup)(process.cwd());
+const server = new mcp_js_1.McpServer({
+    name: "devguard",
+    version: "0.1.0",
+});
+(0, get_context_js_1.registerGetContext)(server);
+(0, write_entry_js_1.registerWriteEntry)(server);
+(0, read_entries_js_1.registerReadEntries)(server);
+(0, catch_me_up_js_1.registerCatchMeUp)(server);
+(0, setup_js_1.registerSetup)(server);
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("devguard MCP server running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/tools/catch-me-up.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerCatchMeUp(server: McpServer): void;

package/dist/tools/catch-me-up.js

@@ -0,0 +1,69 @@
+"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.registerCatchMeUp = registerCatchMeUp;
+const zod_1 = require("zod");
+const git = __importStar(require("../utils/git.js"));
+const storage = __importStar(require("../utils/storage.js"));
+function registerCatchMeUp(server) {
+    server.tool("catch_me_up", "The morning briefing. Reads your recent diary entries and current git state, then returns everything the AI needs to give you a conversational catch-up — like a teammate who was watching over your shoulder.", {
+        project_path: zod_1.z.string().describe("Absolute path to the project directory"),
+    }, async ({ project_path }) => {
+        const parts = [];
+        // Recent diary entries
+        const entries = storage.readEntries(project_path, 3);
+        if (entries.length > 0) {
+            parts.push("## Recent Diary Entries\n");
+            entries.forEach((entry, i) => {
+                parts.push(`### ${i === 0 ? "Latest" : `Entry ${i + 1}`}\n${entry}`);
+            });
+        }
+        else {
+            parts.push("## No previous diary entries found.\n");
+        }
+        // Current git state
+        if (git.isGitRepo(project_path)) {
+            const branch = git.getBranch(project_path);
+            const status = git.getStatus(project_path);
+            const commits = git.getRecentCommits(project_path, 5);
+            const diff = git.getDiffFull(project_path);
+            parts.push(`## Current Git State`, `**Branch:** ${branch}`, `**Working tree:**\n${status || "Clean"}`, `**Recent commits:**\n${commits || "None"}`, `**Uncommitted changes:**\n${diff}`);
+        }
+        parts.push("", "---", "Use all of the above to give the user a conversational catch-up briefing. Be specific — mention file names, branch names, what was last worked on, and where they should probably start today. Talk like a teammate, not a changelog.");
+        return {
+            content: [{ type: "text", text: parts.join("\n\n") }],
+        };
+    });
+}

package/dist/tools/get-context.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetContext(server: McpServer): void;

package/dist/tools/get-context.js

@@ -0,0 +1,69 @@
+"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.registerGetContext = registerGetContext;
+const zod_1 = require("zod");
+const git = __importStar(require("../utils/git.js"));
+function registerGetContext(server) {
+    server.tool("get_context", "Get the current git state of a project — branch, status, recent commits, and diffs. Call this to understand what happened before writing a diary entry.", {
+        project_path: zod_1.z.string().describe("Absolute path to the project directory"),
+    }, async ({ project_path }) => {
+        if (!git.isGitRepo(project_path)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${project_path} is not a git repository. Dev diary works best with git projects.`,
+                    },
+                ],
+            };
+        }
+        const branch = git.getBranch(project_path);
+        const status = git.getStatus(project_path);
+        const commits = git.getRecentCommits(project_path);
+        const diffSummary = git.getDiffSummary(project_path);
+        const diffFull = git.getDiffFull(project_path);
+        const output = [
+            `## Branch\n${branch}`,
+            `## Status\n${status || "Clean working tree"}`,
+            `## Recent Commits\n${commits || "No commits yet"}`,
+            `## Diff Summary\n${diffSummary}`,
+            `## Full Diff\n${diffFull}`,
+        ].join("\n\n");
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    });
+}

package/dist/tools/read-entries.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerReadEntries(server: McpServer): void;

package/dist/tools/read-entries.js

@@ -0,0 +1,67 @@
+"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.registerReadEntries = registerReadEntries;
+const zod_1 = require("zod");
+const storage = __importStar(require("../utils/storage.js"));
+function registerReadEntries(server) {
+    server.tool("read_entries", "Read recent dev diary entries. Call this at the start of a session to catch up on what happened last time.", {
+        project_path: zod_1.z.string().describe("Absolute path to the project directory"),
+        count: zod_1.z
+            .number()
+            .int()
+            .positive()
+            .default(5)
+            .describe("Number of recent entries to return (default 5)"),
+    }, async ({ project_path, count }) => {
+        const entries = storage.readEntries(project_path, count);
+        if (entries.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No diary entries found. Start a session and write your first entry!",
+                    },
+                ],
+            };
+        }
+        const output = entries
+            .map((entry, i) => `${i === 0 ? "## Latest Entry" : `## Entry ${i + 1}`}\n\n${entry}`)
+            .join("\n\n---\n\n");
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    });
+}

package/dist/tools/setup.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSetup(server: McpServer): void;

package/dist/tools/setup.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSetup = registerSetup;
+const zod_1 = require("zod");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const INSTRUCTION = `After completing a task, switching branches, or making a significant commit, call the devguard write_entry tool to log what was done and what's next.`;
+const CONFIG_FILES = ["CLAUDE.md", ".cursorrules"];
+function hasInstruction(content) {
+    return content.includes("devguard write_entry");
+}
+function registerSetup(server) {
+    server.tool("setup", "Add devguard's auto-logging instruction to your project's CLAUDE.md or .cursorrules. Run once per project — it appends the instruction so your AI writes diary entries automatically.", {
+        project_path: zod_1.z.string().describe("Absolute path to the project directory"),
+        target: zod_1.z
+            .enum(["CLAUDE.md", ".cursorrules", "auto"])
+            .default("auto")
+            .describe("Which config file to add the instruction to. 'auto' picks whichever already exists, preferring CLAUDE.md."),
+    }, async ({ project_path, target }) => {
+        let targetFile;
+        if (target === "auto") {
+            // Prefer whichever already exists; default to CLAUDE.md
+            if ((0, fs_1.existsSync)((0, path_1.join)(project_path, "CLAUDE.md"))) {
+                targetFile = "CLAUDE.md";
+            }
+            else if ((0, fs_1.existsSync)((0, path_1.join)(project_path, ".cursorrules"))) {
+                targetFile = ".cursorrules";
+            }
+            else {
+                targetFile = "CLAUDE.md";
+            }
+        }
+        else {
+            targetFile = target;
+        }
+        const filePath = (0, path_1.join)(project_path, targetFile);
+        // Check if already set up
+        if ((0, fs_1.existsSync)(filePath)) {
+            const existing = (0, fs_1.readFileSync)(filePath, "utf-8");
+            if (hasInstruction(existing)) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Already set up — ${targetFile} already contains the devguard instruction.`,
+                        },
+                    ],
+                };
+            }
+            // Append to existing file
+            const section = `\n\n# Dev Diary\n\n${INSTRUCTION}\n`;
+            (0, fs_1.appendFileSync)(filePath, section, "utf-8");
+        }
+        else {
+            // Create new file
+            const content = `# Dev Diary\n\n${INSTRUCTION}\n`;
+            (0, fs_1.writeFileSync)(filePath, content, "utf-8");
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Done — added devguard instruction to ${targetFile}. Your AI will now log diary entries automatically.`,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/write-entry.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerWriteEntry(server: McpServer): void;

package/dist/tools/write-entry.js

@@ -0,0 +1,94 @@
+"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.registerWriteEntry = registerWriteEntry;
+const zod_1 = require("zod");
+const git = __importStar(require("../utils/git.js"));
+const storage = __importStar(require("../utils/storage.js"));
+function registerWriteEntry(server) {
+    server.tool("write_entry", "Save a dev diary entry. Captures what changed, decisions made, issues hit, and what's next. Call get_context first to gather the raw material.", {
+        project_path: zod_1.z.string().describe("Absolute path to the project directory"),
+        summary: zod_1.z.string().describe("One-line summary of what happened this session"),
+        changes: zod_1.z.string().describe("What changed — files modified, features added, bugs fixed"),
+        decisions: zod_1.z
+            .string()
+            .optional()
+            .describe("Key decisions made and why"),
+        issues: zod_1.z
+            .string()
+            .optional()
+            .describe("What broke, what's stuck, errors encountered"),
+        next_steps: zod_1.z
+            .string()
+            .optional()
+            .describe("What to do next session"),
+    }, async ({ project_path, summary, changes, decisions, issues, next_steps }) => {
+        const branch = git.isGitRepo(project_path)
+            ? git.getBranch(project_path)
+            : "unknown";
+        const now = new Date().toISOString();
+        const sections = [
+            `---`,
+            `date: ${now}`,
+            `branch: ${branch}`,
+            `summary: "${summary}"`,
+            `---`,
+            "",
+            `# ${summary}`,
+            "",
+            `## What Changed`,
+            changes,
+        ];
+        if (decisions) {
+            sections.push("", "## Decisions", decisions);
+        }
+        if (issues) {
+            sections.push("", "## Issues", issues);
+        }
+        if (next_steps) {
+            sections.push("", "## Next Steps", next_steps);
+        }
+        const content = sections.join("\n") + "\n";
+        const filePath = storage.writeEntry(project_path, content);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Diary entry saved: ${filePath}`,
+                },
+            ],
+        };
+    });
+}

package/dist/utils/auto-setup.d.ts

@@ -0,0 +1 @@
+export declare function autoSetup(projectPath: string): void;

package/dist/utils/auto-setup.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoSetup = autoSetup;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const GITIGNORE_ENTRY = ".devguard/";
+const INSTRUCTION = `After completing a task, switching branches, or making a significant commit, call the devguard write_entry tool to log what was done and what's next.`;
+function autoSetup(projectPath) {
+    addToGitignore(projectPath);
+    addInstruction(projectPath);
+}
+function addToGitignore(projectPath) {
+    const gitignorePath = (0, path_1.join)(projectPath, ".gitignore");
+    if ((0, fs_1.existsSync)(gitignorePath)) {
+        const content = (0, fs_1.readFileSync)(gitignorePath, "utf-8");
+        if (content.includes(GITIGNORE_ENTRY))
+            return;
+        (0, fs_1.appendFileSync)(gitignorePath, `\n${GITIGNORE_ENTRY}\n`, "utf-8");
+    }
+    else {
+        (0, fs_1.writeFileSync)(gitignorePath, `${GITIGNORE_ENTRY}\n`, "utf-8");
+    }
+    console.error(`devguard: added ${GITIGNORE_ENTRY} to .gitignore`);
+}
+function addInstruction(projectPath) {
+    const claudeMd = (0, path_1.join)(projectPath, "CLAUDE.md");
+    const cursorrules = (0, path_1.join)(projectPath, ".cursorrules");
+    // Pick target: prefer whichever exists, default to CLAUDE.md
+    let targetPath;
+    let targetName;
+    if ((0, fs_1.existsSync)(claudeMd)) {
+        targetPath = claudeMd;
+        targetName = "CLAUDE.md";
+    }
+    else if ((0, fs_1.existsSync)(cursorrules)) {
+        targetPath = cursorrules;
+        targetName = ".cursorrules";
+    }
+    else {
+        targetPath = claudeMd;
+        targetName = "CLAUDE.md";
+    }
+    // Already has it?
+    if ((0, fs_1.existsSync)(targetPath)) {
+        const content = (0, fs_1.readFileSync)(targetPath, "utf-8");
+        if (content.includes("devguard write_entry"))
+            return;
+        (0, fs_1.appendFileSync)(targetPath, `\n\n# Dev Diary\n\n${INSTRUCTION}\n`, "utf-8");
+    }
+    else {
+        (0, fs_1.writeFileSync)(targetPath, `# Dev Diary\n\n${INSTRUCTION}\n`, "utf-8");
+    }
+    console.error(`devguard: added auto-logging instruction to ${targetName}`);
+}

package/dist/utils/git.d.ts

@@ -0,0 +1,6 @@
+export declare function isGitRepo(cwd: string): boolean;
+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 getDiffFull(cwd: string): string;

package/dist/utils/git.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitRepo = isGitRepo;
+exports.getBranch = getBranch;
+exports.getStatus = getStatus;
+exports.getRecentCommits = getRecentCommits;
+exports.getDiffSummary = getDiffSummary;
+exports.getDiffFull = getDiffFull;
+const child_process_1 = require("child_process");
+function run(cmd, cwd) {
+    try {
+        return (0, child_process_1.execSync)(cmd, { cwd, encoding: "utf-8", timeout: 10_000 }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function isGitRepo(cwd) {
+    return run("git rev-parse --is-inside-work-tree", cwd) === "true";
+}
+function getBranch(cwd) {
+    return run("git branch --show-current", cwd) || "detached HEAD";
+}
+function getStatus(cwd) {
+    return run("git status --short", cwd);
+}
+function getRecentCommits(cwd, count = 10) {
+    return run(`git log --oneline --no-decorate -n ${count}`, cwd);
+}
+function getDiffSummary(cwd) {
+    const staged = run("git diff --cached --stat", cwd);
+    const unstaged = run("git diff --stat", cwd);
+    const parts = [];
+    if (staged)
+        parts.push(`Staged:\n${staged}`);
+    if (unstaged)
+        parts.push(`Unstaged:\n${unstaged}`);
+    return parts.join("\n\n") || "No changes";
+}
+function getDiffFull(cwd) {
+    const staged = run("git diff --cached", cwd);
+    const unstaged = run("git diff", cwd);
+    const parts = [];
+    if (staged)
+        parts.push(`--- Staged changes ---\n${staged}`);
+    if (unstaged)
+        parts.push(`--- Unstaged changes ---\n${unstaged}`);
+    // Truncate to avoid overwhelming context
+    const combined = parts.join("\n\n") || "No changes";
+    if (combined.length > 8000) {
+        return combined.slice(0, 8000) + "\n\n... (truncated, use diff summary for full picture)";
+    }
+    return combined;
+}

package/dist/utils/storage.d.ts

@@ -0,0 +1,3 @@
+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[];

package/dist/utils/storage.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDiaryDir = ensureDiaryDir;
+exports.writeEntry = writeEntry;
+exports.readEntries = readEntries;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const DIARY_DIR = ".devguard";
+const ENTRIES_DIR = "entries";
+function entriesPath(projectPath) {
+    return (0, path_1.join)(projectPath, DIARY_DIR, ENTRIES_DIR);
+}
+function ensureDiaryDir(projectPath) {
+    const dir = entriesPath(projectPath);
+    (0, fs_1.mkdirSync)(dir, { recursive: true });
+    return dir;
+}
+function writeEntry(projectPath, content) {
+    const dir = ensureDiaryDir(projectPath);
+    const now = new Date();
+    const filename = formatDate(now) + ".md";
+    const filePath = (0, path_1.join)(dir, filename);
+    const time = formatTime(now);
+    const separator = `\n\n---\n\n<!-- session: ${time} -->\n\n`;
+    if ((0, fs_1.existsSync)(filePath)) {
+        (0, fs_1.appendFileSync)(filePath, separator + content, "utf-8");
+    }
+    else {
+        (0, fs_1.writeFileSync)(filePath, content, "utf-8");
+    }
+    return filePath;
+}
+function readEntries(projectPath, count) {
+    const dir = entriesPath(projectPath);
+    if (!(0, fs_1.existsSync)(dir))
+        return [];
+    const files = (0, fs_1.readdirSync)(dir)
+        .filter((f) => f.endsWith(".md"))
+        .sort()
+        .reverse()
+        .slice(0, count);
+    return files.map((f) => (0, fs_1.readFileSync)((0, path_1.join)(dir, f), "utf-8"));
+}
+function formatDate(date) {
+    const y = date.getFullYear();
+    const mo = String(date.getMonth() + 1).padStart(2, "0");
+    const d = String(date.getDate()).padStart(2, "0");
+    return `${y}-${mo}-${d}`;
+}
+function formatTime(date) {
+    const h = String(date.getHours()).padStart(2, "0");
+    const mi = String(date.getMinutes()).padStart(2, "0");
+    return `${h}:${mi}`;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "devguard",
+  "version": "0.1.0",
+  "description": "MCP server that auto-generates dev diary entries from git activity",
+  "license": "MIT",
+  "bin": {
+    "devguard": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "inspect": "npx @modelcontextprotocol/inspector tsx src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}