codiedev 0.2.0 → 0.3.0

package/dist/commands/shared.js

@@ -0,0 +1,143 @@
+"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.requireConfig = requireConfig;
+exports.apiRequest = apiRequest;
+exports.timeAgo = timeAgo;
+exports.stripQuotes = stripQuotes;
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const utils_1 = require("../utils");
+/**
+ * Require a connected CodieDev config. Exits the process with a helpful
+ * message if the user hasn't run `codiedev connect` yet.
+ */
+function requireConfig() {
+    const config = (0, utils_1.readConfig)();
+    if (!config) {
+        console.error("Not connected. Run `npx codiedev connect` first and enter your API token.");
+        process.exit(1);
+    }
+    return config;
+}
+/**
+ * Perform an authenticated HTTP request against the CodieDev backend.
+ * Returns the parsed JSON response body. Throws on non-2xx.
+ */
+function apiRequest(method, path, options) {
+    return new Promise((resolve, reject) => {
+        const base = options.config.backendUrl;
+        const url = new URL(path, base);
+        if (options.query) {
+            for (const [k, v] of Object.entries(options.query)) {
+                if (v === undefined)
+                    continue;
+                url.searchParams.set(k, String(v));
+            }
+        }
+        const data = options.body ? JSON.stringify(options.body) : undefined;
+        const requestOptions = {
+            hostname: url.hostname,
+            port: url.port || (url.protocol === "https:" ? 443 : 80),
+            path: url.pathname + url.search,
+            method,
+            headers: {
+                Authorization: `Bearer ${options.config.token}`,
+                ...(data
+                    ? {
+                        "Content-Type": "application/json",
+                        "Content-Length": Buffer.byteLength(data),
+                    }
+                    : {}),
+            },
+        };
+        const lib = url.protocol === "https:" ? https : http;
+        const req = lib.request(requestOptions, (res) => {
+            let chunks = "";
+            res.on("data", (c) => (chunks += c));
+            res.on("end", () => {
+                try {
+                    const parsed = chunks ? JSON.parse(chunks) : {};
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(parsed);
+                    }
+                    else {
+                        const errMsg = (parsed && typeof parsed === "object" && "error" in parsed
+                            ? parsed.error
+                            : undefined) || `HTTP ${res.statusCode}`;
+                        reject(Object.assign(new Error(errMsg), {
+                            status: res.statusCode,
+                            body: parsed,
+                        }));
+                    }
+                }
+                catch {
+                    reject(new Error(`Failed to parse response: ${chunks}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        if (data)
+            req.write(data);
+        req.end();
+    });
+}
+/**
+ * Relative-time formatter for inbox / listing output.
+ */
+function timeAgo(ts) {
+    const diff = Date.now() - ts;
+    const mins = Math.floor(diff / 60000);
+    if (mins < 1)
+        return "just now";
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+/**
+ * Strip surrounding quotes from a CLI argument if the user wrapped it.
+ * `codiedev ping maya "hey"` on some shells passes the quotes through.
+ */
+function stripQuotes(s) {
+    if ((s.startsWith('"') && s.endsWith('"')) ||
+        (s.startsWith("'") && s.endsWith("'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}

package/dist/connect.d.ts

@@ -1,2 +1 @@
-#!/usr/bin/env node
-export {};
+export declare function runConnect(): Promise<void>;

package/dist/connect.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -34,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConnect = runConnect;
 const readline = __importStar(require("readline"));
 const https = __importStar(require("https"));
 const http = __importStar(require("http"));
@@ -86,13 +86,13 @@ function postJson(url, body) {
         req.end();
     });
 }
-async function main() {
+async function runConnect() {
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
     console.log("\nWelcome to CodieDev CLI\n");
-    console.log("This will connect Claude Code to your CodieDev workspace and install");
+    console.log("This will connect your coding agent to your CodieDev workspace and install");
     console.log("the session capture hook for org-wide session sharing.\n");
     let token;
     try {
@@ -145,20 +145,36 @@ async function main() {
     if (hasClaude) {
         try {
             (0, utils_1.installHook)();
-            installed.push("Claude Code (SessionEnd → ~/.claude/settings.json)");
+            installed.push("Claude Code SessionEnd hook (~/.claude/settings.json)");
         }
         catch (err) {
             console.error(`\nWarning: Failed to install Claude Code hook — ${err.message}`);
         }
+        try {
+            (0, utils_1.installClaudeCodeMcp)();
+            installed.push("Claude Code MCP server (~/.claude.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Claude Code MCP server — ${err.message}`);
+        }
     }
     if (hasCodex) {
         try {
             (0, utils_1.installCodexHook)();
-            installed.push("Codex (Stop → ~/.codex/hooks.json)");
+            installed.push("Codex Stop hook (~/.codex/hooks.json)");
         }
         catch (err) {
             console.error(`\nWarning: Failed to install Codex hook — ${err.message}`);
         }
+        try {
+            const added = (0, utils_1.installCodexMcp)();
+            if (added) {
+                installed.push("Codex MCP server (~/.codex/config.toml)");
+            }
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Codex MCP server — ${err.message}`);
+        }
     }
     if (!hasClaude && !hasCodex) {
         console.warn("\nNo Claude Code (~/.claude) or Codex (~/.codex) install detected.");
@@ -177,7 +193,3 @@ async function main() {
         console.log();
     }
 }
-main().catch((err) => {
-    console.error("Unexpected error:", err);
-    process.exit(1);
-});

package/dist/mcp.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * CodieDev MCP server.
+ *
+ * Exposes the CodieDev artifact-collaboration surface as Model Context
+ * Protocol tools so Claude Code / Codex / any MCP-capable agent can invoke
+ * them natively from natural language (e.g. "push the spec we just worked on").
+ *
+ * Reads the same ~/.codiedev/config.json the CLI uses. Install + wire up by
+ * running `npx codiedev connect`.
+ */
+export {};

package/dist/mcp.js

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * CodieDev MCP server.
+ *
+ * Exposes the CodieDev artifact-collaboration surface as Model Context
+ * Protocol tools so Claude Code / Codex / any MCP-capable agent can invoke
+ * them natively from natural language (e.g. "push the spec we just worked on").
+ *
+ * Reads the same ~/.codiedev/config.json the CLI uses. Install + wire up by
+ * running `npx codiedev connect`.
+ */
+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 });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const utils_1 = require("./utils");
+const shared_1 = require("./commands/shared");
+const PKG_NAME = "codiedev";
+const PKG_VERSION = "0.3.0";
+// ─────────────────────────────────────────────────────────────────────────────
+// Tool definitions — descriptions tuned so Claude/Codex resolve natural-language
+// requests into the right tool without manual steering.
+// ─────────────────────────────────────────────────────────────────────────────
+const TOOLS = [
+    {
+        name: "codiedev_push",
+        description: "Push a spec, review, decision, proposal, bugfix, or note to the " +
+            "team's CodieDev artifact layer so teammates can see and discuss it. " +
+            "Use when the user asks to share, push, save, or publish something " +
+            "(e.g., 'push this spec', 'share the review with the team', 'save as " +
+            "a decision'). Prefer passing the filename of a recently-edited local " +
+            "file — provide its current contents as `markdown`. Filename should " +
+            "end in .md and start with the artifact type (spec-, review-, " +
+            "decision-, proposal-, bugfix-, or note-).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filename: {
+                    type: "string",
+                    description: "Basename of the artifact file, e.g. 'spec-214.md'. Becomes the " +
+                        "artifact's key for pulling and pinging.",
+                },
+                markdown: {
+                    type: "string",
+                    description: "Full markdown content of the artifact.",
+                },
+                type: {
+                    type: "string",
+                    enum: ["spec", "bugfix", "decision", "proposal", "review", "note"],
+                    description: "Override the inferred type. Usually leave unset — type is " +
+                        "inferred from filename prefix.",
+                },
+            },
+            required: ["filename", "markdown"],
+        },
+    },
+    {
+        name: "codiedev_pull",
+        description: "Fetch an artifact (spec, review, decision, proposal, bugfix, or " +
+            "note) from the team's CodieDev artifact layer. Use when the user " +
+            "asks to pull, grab, fetch, or resume work on a named artifact, or " +
+            "when they want to see what a teammate pushed. Returns the full " +
+            "markdown content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: {
+                    type: "string",
+                    description: "Filename key of the artifact to pull, e.g. 'spec-214.md'.",
+                },
+                version: {
+                    type: "integer",
+                    description: "Specific version to pull. Omit for the latest version.",
+                },
+            },
+            required: ["key"],
+        },
+    },
+    {
+        name: "codiedev_ping",
+        description: "Send a message to a teammate on CodieDev, optionally attached to a " +
+            "specific artifact. Use when the user asks to ping, ask, share with, " +
+            "or get feedback from a teammate by name (e.g. 'ping Maya about this " +
+            "spec'). Recipients are resolved by first name, full name, or email " +
+            "within the current org. They're notified by email and can reply " +
+            "from their own agent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                to: {
+                    type: "string",
+                    description: "Teammate's first name, full name, or email. Ambiguous matches " +
+                        "return a list of candidates — reprompt the user if so.",
+                },
+                body: {
+                    type: "string",
+                    description: "Message body — the actual ask/comment.",
+                },
+                subjectKey: {
+                    type: "string",
+                    description: "Optional filename key of an artifact the message is about " +
+                        "(e.g. 'spec-214.md'). Leaving blank sends a standalone ping.",
+                },
+            },
+            required: ["to", "body"],
+        },
+    },
+    {
+        name: "codiedev_inbox",
+        description: "Check the user's CodieDev inbox for messages from teammates. Use " +
+            "when the user asks 'any messages?', 'what did [name] say?', 'check " +
+            "my inbox', or when they open a session and want to catch up on " +
+            "what's waiting for them. Returns a list with sender, subject " +
+            "artifact, time, and preview.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                unreadOnly: {
+                    type: "boolean",
+                    description: "Only return unread pings. Default false.",
+                },
+                limit: {
+                    type: "integer",
+                    description: "Max pings to return. Default 50.",
+                },
+            },
+        },
+    },
+    {
+        name: "codiedev_note",
+        description: "Capture a passing thought and link it to the current agent session. " +
+            "Use when the user says 'note that', 'remember', 'worth capturing', " +
+            "'jot this down', or drops a short observation that isn't a full " +
+            "spec. Notes show up in the user's CodieDev memory feed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                body: {
+                    type: "string",
+                    description: "The thought to capture.",
+                },
+            },
+            required: ["body"],
+        },
+    },
+    {
+        name: "codiedev_promote",
+        description: "Promote an auto-extracted CodieDev artifact (spec/bugfix/decision " +
+            "produced by the session-capture pipeline) to an authored artifact " +
+            "so teammates can collaborate on it. Use when the user says 'publish " +
+            "the extracted spec', 'promote this', or 'make the auto-extracted X " +
+            "shareable'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifactId: {
+                    type: "string",
+                    description: "The extracted artifact's id from CodieDev.",
+                },
+                keyOverride: {
+                    type: "string",
+                    description: "Optional filename key for the promoted artifact. If omitted, " +
+                        "one is generated from the artifact's type + session id.",
+                },
+            },
+            required: ["artifactId"],
+        },
+    },
+];
+// ─────────────────────────────────────────────────────────────────────────────
+// Server
+// ─────────────────────────────────────────────────────────────────────────────
+const server = new index_js_1.Server({ name: PKG_NAME, version: PKG_VERSION }, { capabilities: { tools: {} } });
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: TOOLS,
+}));
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const config = (0, utils_1.readConfig)();
+    if (!config) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: "CodieDev is not connected on this machine. Ask the user to run " +
+                        "`npx codiedev connect` with an API token from " +
+                        "https://codiedev.com/portal/integrations/claude-code.",
+                },
+            ],
+        };
+    }
+    const { name, arguments: argsRaw } = request.params;
+    const args = (argsRaw ?? {});
+    try {
+        switch (name) {
+            case "codiedev_push":
+                return await handlePush(args, config);
+            case "codiedev_pull":
+                return await handlePull(args, config);
+            case "codiedev_ping":
+                return await handlePing(args, config);
+            case "codiedev_inbox":
+                return await handleInbox(args, config);
+            case "codiedev_note":
+                return await handleNote(args, config);
+            case "codiedev_promote":
+                return await handlePromote(args, config);
+            default:
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                };
+        }
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `CodieDev error: ${err.message}`,
+                },
+            ],
+        };
+    }
+});
+async function handlePush(args, config) {
+    const filename = asString(args.filename);
+    const markdown = asString(args.markdown);
+    const type = asStringOrUndefined(args.type);
+    if (!filename)
+        throw new Error("filename required");
+    if (!markdown)
+        throw new Error("markdown required");
+    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/push", {
+        config,
+        body: { filename, markdown, type },
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `✓ Pushed ${filename} (type=${res.type}, version=v${res.version}, id=${res.artifactId}).\n` +
+                    `Teammates can now pull it with \`codiedev pull ${filename}\`.`,
+            },
+        ],
+    };
+}
+async function handlePull(args, config) {
+    const key = asString(args.key);
+    const version = asIntOrUndefined(args.version);
+    if (!key)
+        throw new Error("key required");
+    const res = await (0, shared_1.apiRequest)("GET", "/api/cli/pull", { config, query: { key, version } });
+    const a = res.artifact;
+    const header = `# ${a.title}\n\n` +
+        `**${a.type}** · v${a.version ?? 1} · ${a.lifecycle ?? "draft"} · ` +
+        `updated ${(0, shared_1.timeAgo)(a.updatedAt ?? a.createdAt)}\n\n---\n\n`;
+    return {
+        content: [{ type: "text", text: header + a.markdown }],
+    };
+}
+async function handlePing(args, config) {
+    const to = asString(args.to);
+    const body = asString(args.body);
+    const subjectKey = asStringOrUndefined(args.subjectKey);
+    if (!to)
+        throw new Error("to required");
+    if (!body)
+        throw new Error("body required");
+    try {
+        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/ping", { config, body: { to, body, subjectKey } });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✓ Pinged ${res.recipient.name} <${res.recipient.email}>` +
+                        (subjectKey ? ` about ${subjectKey}.` : "."),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const e = err;
+        if (e.status === 409 && e.body?.candidates?.length) {
+            const list = e.body.candidates
+                .map((c) => `- ${c.name} <${c.email}>`)
+                .join("\n");
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `Multiple recipients matched "${to}". Ask the user which:\n${list}`,
+                    },
+                ],
+            };
+        }
+        throw err;
+    }
+}
+async function handleInbox(args, config) {
+    const unreadOnly = args.unreadOnly === true;
+    const limit = asIntOrUndefined(args.limit);
+    const res = await (0, shared_1.apiRequest)("GET", "/api/cli/inbox", {
+        config,
+        query: { unreadOnly: unreadOnly ? "1" : undefined, limit },
+    });
+    if (res.pings.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: unreadOnly ? "No unread messages." : "Inbox is empty.",
+                },
+            ],
+        };
+    }
+    const unreadCount = res.pings.filter((p) => !p.readAt).length;
+    const lines = [
+        `Inbox · ${res.pings.length} ${unreadOnly ? "unread" : "recent"}${unreadOnly ? "" : ` · ${unreadCount} unread`}`,
+        "",
+    ];
+    for (const p of res.pings) {
+        const status = p.readAt ? "·" : "●";
+        const from = p.from?.name ?? "unknown";
+        const where = p.subjectKey ? ` · on ${p.subjectKey}` : "";
+        lines.push(`${status} ${from}${where} · ${(0, shared_1.timeAgo)(p.createdAt)}`);
+        lines.push(`    ${p.preview || "(no body)"}`);
+        lines.push(`    id: ${p.pingId}`);
+        lines.push("");
+    }
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+    };
+}
+async function handleNote(args, config) {
+    const body = asString(args.body);
+    if (!body)
+        throw new Error("body required");
+    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/note", { config, body: { body } });
+    return {
+        content: [{ type: "text", text: `✓ Noted (${res.key})` }],
+    };
+}
+async function handlePromote(args, config) {
+    const artifactId = asString(args.artifactId);
+    const keyOverride = asStringOrUndefined(args.keyOverride);
+    if (!artifactId)
+        throw new Error("artifactId required");
+    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/promote", { config, body: { artifactId, keyOverride } });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `✓ Promoted to authored artifact ${res.key} (id=${res.artifactId}).`,
+            },
+        ],
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+function asString(v) {
+    return typeof v === "string" ? v : "";
+}
+function asStringOrUndefined(v) {
+    return typeof v === "string" ? v : undefined;
+}
+function asIntOrUndefined(v) {
+    return typeof v === "number" && Number.isInteger(v) ? v : undefined;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Main
+// ─────────────────────────────────────────────────────────────────────────────
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // stdio transport handles I/O until process exits.
+    // Log to stderr only — stdout is reserved for MCP protocol.
+    process.stderr.write(`[codiedev-mcp] ready (v${PKG_VERSION}, config ${(0, utils_1.readConfig)() ? "present" : "missing"})\n`);
+}
+main().catch((err) => {
+    process.stderr.write(`[codiedev-mcp] fatal: ${err.message}\n`);
+    process.exit(1);
+});
+// Avoid "Cannot find name 'path', 'fs'" since we imported them but may not use.
+void path;
+void fs;

package/dist/utils.d.ts

@@ -27,6 +27,18 @@ export declare function hashToken(token: string): string;
 export declare function claudeCodeInstalled(): boolean;
 export declare function codexInstalled(): boolean;
 export declare function installHook(): void;
+/**
+ * Install the CodieDev MCP server into Claude Code's user-scope config.
+ * Safe to call multiple times — updates the existing entry if present.
+ */
+export declare function installClaudeCodeMcp(): void;
+/**
+ * Best-effort append of the CodieDev MCP server block to ~/.codex/config.toml.
+ *
+ * Codex uses TOML and we don't want a full parser for such a small addition,
+ * so we append a well-marked block if one isn't already present. Idempotent.
+ */
+export declare function installCodexMcp(): boolean;
 export declare function installCodexHook(): void;
 export interface ParsedStats {
     messageCount: number;