codiedev 0.10.0-beta.4 → 0.10.0-beta.5

package/dist/mcp.js

@@ -1,15 +1,5 @@
 #!/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);
@@ -45,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const skillMarker_1 = require("./skillMarker");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const fs = __importStar(require("fs"));
@@ -53,8 +44,6 @@ const utils_1 = require("./utils");
 const shared_1 = require("./commands/shared");
 const inboxFormat_1 = require("./inboxFormat");
 const PKG_NAME = "codiedev";
-// Read version from the bundled package.json so the startup log + tool reports
-// always reflect the actually-installed version, rather than a stale constant.
 const PKG_VERSION = (() => {
     try {
         const pkgPath = path.resolve(__dirname, "..", "package.json");
@@ -64,10 +53,6 @@ const PKG_VERSION = (() => {
         return "unknown";
     }
 })();
-// ─────────────────────────────────────────────────────────────────────────────
-// Tool definitions — descriptions tuned so Claude/Codex resolve natural-language
-// requests into the right tool without manual steering.
-// ─────────────────────────────────────────────────────────────────────────────
 const TOOLS = [
     {
         name: "codiedev_push",
@@ -449,17 +434,10 @@ const TOOLS = [
         },
     },
 ];
-// ─────────────────────────────────────────────────────────────────────────────
-// 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,
 }));
-/**
- * Fire-and-forget telemetry — POST one event per tool invocation. Never blocks,
- * never throws into the user-facing path. Drop silently on any failure.
- */
 function emitTelemetry(config, event) {
     if (!config)
         return;
@@ -473,7 +451,6 @@ function emitTelemetry(config, event) {
             mcpVersion: PKG_VERSION,
         },
     }).catch(() => {
-        // Swallow — telemetry should never affect the user's session.
     });
 }
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
@@ -577,7 +554,7 @@ async function handlePush(args, config) {
     }
     const res = await (0, shared_1.apiRequest)("POST", "/api/cli/push", {
         config,
-        body: { filename, markdown, type, kind, tags, force },
+        body: { filename, markdown: (0, skillMarker_1.stripSkillMarker)(markdown), type, kind, tags, force },
     });
     const tagSummary = res.tags && res.tags.length > 0 ? `, tags=[${res.tags.join(", ")}]` : "";
     return {
@@ -598,10 +575,6 @@ async function handlePull(args, config) {
         throw new Error("key required");
     const res = await (0, shared_1.apiRequest)("GET", "/api/cli/pull", { config, query: { key, version } });
     const a = res.artifact;
-    // Lead with the new-vocab kind. Legacy doc-shape (spec/decision/...) is
-    // surfaced as a tag list after, so callers still see it but it's no
-    // longer the primary label. Falls back to "doc" if the row pre-dates the
-    // kind field.
     const kindLabel = a.kind ?? "doc";
     const tagList = (a.tags ?? []).filter((t) => t).join(", ");
     const tagSuffix = tagList ? ` · tags: ${tagList}` : "";
@@ -609,7 +582,7 @@ async function handlePull(args, config) {
         `**${kindLabel}** · v${a.version ?? 1} · ${a.lifecycle ?? "draft"}${tagSuffix} · ` +
         `updated ${(0, shared_1.timeAgo)(a.updatedAt ?? a.createdAt)}\n\n---\n\n`;
     return {
-        content: [{ type: "text", text: header + a.markdown }],
+        content: [{ type: "text", text: header + (a.kind === "skill" || (!a.kind && (0, skillMarker_1.looksLikeSkill)(a.markdown)) ? (0, skillMarker_1.stampSkillMarker)(a.markdown, a._id) : a.markdown) }],
     };
 }
 async function handleDelete(args, config) {
@@ -685,9 +658,6 @@ async function handleInbox(args, config) {
         config,
         query: { unreadOnly: unreadOnly ? "1" : undefined, limit },
     });
-    // Shared with `codiedev inbox` so this agent-facing path can never drift
-    // back to pings-only. CLAUDE.md routes "any messages?" here, so a
-    // mentions-blind version reproduces the bug for agents.
     const text = (0, inboxFormat_1.formatInbox)({
         pings: res.pings,
         mentions: res.mentions,
@@ -754,8 +724,6 @@ async function handleShareWith(args, config) {
                 ],
             };
         }
-        // noop / duplicate path — surface where the existing grant came from so
-        // the user knows whether to expect it next time.
         const e = res.existing;
         let why = "";
         if (e) {
@@ -908,9 +876,6 @@ async function handleGetLibrary(args, config) {
         const v = a.version ? ` v${a.version}` : "";
         const life = a.lifecycle ? ` · ${a.lifecycle}` : "";
         const when = a.updatedAt ? ` · ${(0, shared_1.timeAgo)(a.updatedAt)}` : "";
-        // Lead with the canonical kind (doc | skill). Tags carry the legacy
-        // doc-shape (spec/decision/...) plus any author-added labels — surface
-        // them after the kind so the row is self-describing.
         const k = a.kind ?? (a.type === "note" ? "doc" : "doc");
         const tagList = (a.tags ?? []).length > 0 ? ` [${a.tags.join(", ")}]` : "";
         lines.push(`[${k}]${tagList} ${loc}${a.key ?? a.title}${v}${life}${when}`);
@@ -941,7 +906,6 @@ async function handleReverseTicket(args, config) {
     const explicitTitle = asStringOrUndefined(args.title);
     const explicitBase = asStringOrUndefined(args.base);
     const forcedKey = asStringOrUndefined(args.forcedArtifactKey);
-    // Helper that runs git from cwd with a hard-fail on error.
     const { execSync } = await Promise.resolve().then(() => __importStar(require("child_process")));
     const git = (cmd) => {
         try {
@@ -956,14 +920,12 @@ async function handleReverseTicket(args, config) {
             throw new Error(`git ${cmd} failed: ${err.message}`);
         }
     };
-    // Confirm we're in a git repo.
     try {
         git("rev-parse --is-inside-work-tree");
     }
     catch {
         throw new Error("Not inside a git repository. Run this from a checked-out repo.");
     }
-    // Resolve base ref — explicit, then origin/main, then origin/master.
     const candidates = explicitBase
         ? [explicitBase]
         : ["origin/main", "origin/master"];
@@ -975,7 +937,6 @@ async function handleReverseTicket(args, config) {
             break;
         }
         catch {
-            // try next
         }
     }
     if (!baseRef) {
@@ -988,10 +949,6 @@ async function handleReverseTicket(args, config) {
     }
     const baseSha = git(`merge-base HEAD ${baseRef}`);
     const headSha = git("rev-parse HEAD");
-    // Filter generated/lockfile noise so the LLM's diff budget gets spent on
-    // real source. The --stat block (collected separately below) still includes
-    // every file untouched, so excluded files still appear in the ticket's
-    // "Other files touched" section if relevant.
     const isNoise = (p) => /(^|\/)(node_modules|dist|build|\.next|\.turbo|coverage|out)\//.test(p) ||
         /(^|\/)package-lock\.json$/.test(p) ||
         /(^|\/)yarn\.lock$/.test(p) ||
@@ -1001,9 +958,6 @@ async function handleReverseTicket(args, config) {
         /(^|\/)Gemfile\.lock$/.test(p) ||
         /(^|\/)poetry\.lock$/.test(p) ||
         /(^|\/)go\.sum$/.test(p);
-    // Helper: run a shell command tolerating non-zero exit codes (git diff
-    // --no-index exits 1 when files differ, which is the normal case).
-    // Reuses the execSync already imported above for the git() helper.
     const shellTolerant = (cmd) => {
         try {
             return execSync(`${cmd} || true`, {
@@ -1018,12 +972,6 @@ async function handleReverseTicket(args, config) {
         }
     };
     const shQuote = (s) => `'${s.replace(/'/g, "'\\''")}'`;
-    // Capture all work the developer has done relative to the base ref:
-    //   - committed changes between base and HEAD
-    //   - uncommitted modifications to tracked files
-    //   - new untracked files (path listed + content via synthetic diff)
-    // Matches the user's intent ("ticket my current changes") rather than the
-    // narrower "only what's been committed" interpretation.
     const trackedRaw = git(`diff --name-only ${baseSha}`);
     const trackedFiles = trackedRaw ? trackedRaw.split("\n").filter(Boolean) : [];
     const untrackedRaw = safeGit(() => git("ls-files --others --exclude-standard"));
@@ -1034,9 +982,6 @@ async function handleReverseTicket(args, config) {
     if (filesChanged.length === 0) {
         throw new Error(`No changes detected between ${baseRef} and your working tree on ${branch}.`);
     }
-    // --stat block: compact ground truth for "every file touched". Tracked
-    // changes from `git diff --stat baseSha`; untracked files appended as
-    // synthesized stat rows so the LLM sees them with line counts.
     let stat = "";
     try {
         const trackedStat = git(`diff --stat=200 ${baseSha}`);
@@ -1051,10 +996,7 @@ async function handleReverseTicket(args, config) {
             .slice(0, 8_000);
     }
     catch {
-        // Best effort.
     }
-    // Diff body: 40k cap, noise-filtered. Tracked changes via `git diff baseSha`,
-    // plus synthetic add-only diffs for untracked files via `git diff --no-index`.
     let diff = "";
     try {
         const sourceTracked = trackedFiles.filter((f) => !isNoise(f));
@@ -1069,9 +1011,7 @@ async function handleReverseTicket(args, config) {
             .slice(0, 40_000);
     }
     catch {
-        // Best effort.
     }
-    // Repo name from origin remote.
     let repo;
     try {
         const remoteUrl = git("config --get remote.origin.url");
@@ -1087,7 +1027,6 @@ async function handleReverseTicket(args, config) {
     const title = explicitTitle ?? safeGit(() => git("log -1 --format=%s")) ?? `WIP: ${branch}`;
     const author = safeGit(() => git("config --get user.name"));
     const authorEmail = safeGit(() => git("config --get user.email"));
-    // Post to backend.
     const res = await (0, shared_1.apiRequest)("POST", "/api/cli/reverseTicketFromBranch", {
         config,
         body: {
@@ -1120,9 +1059,6 @@ async function handleReverseTicket(args, config) {
             ],
         };
     }
-    // Always return an absolute URL so MCP clients (Copilot Chat, Claude Code,
-    // etc.) can render the link correctly without guessing a host. Default to
-    // codiedev.com; allow override via CODIEDEV_PORTAL_URL for self-hosted.
     const portalHost = (process.env.CODIEDEV_PORTAL_URL || "https://codiedev.com").replace(/\/$/, "");
     const portalLink = res.portalUrl.startsWith("http")
         ? res.portalUrl
@@ -1145,7 +1081,6 @@ async function handleReverseTicket(args, config) {
         ],
     };
 }
-// Run a git invocation; return undefined instead of throwing.
 function safeGit(fn) {
     try {
         return fn();
@@ -1154,9 +1089,6 @@ function safeGit(fn) {
         return undefined;
     }
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────────────────
 function asString(v) {
     return typeof v === "string" ? v : "";
 }
@@ -1174,20 +1106,14 @@ function asStringArrayOrUndefined(v) {
         return undefined;
     return v.filter((x) => typeof x === "string");
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// 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/nativeSteering.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNativeSteering = parseNativeSteering;
+function parseNativeSteering(content) {
+    const interrupts = new Set();
+    const abortedTurns = new Set();
+    const rejections = new Set();
+    for (const [index, line] of content.split("\n").entries()) {
+        try {
+            const event = JSON.parse(line);
+            const id = String(event.id ?? event.uuid ?? event.toolCallId ?? index);
+            if (event.type === "agent.interruption")
+                interrupts.add(id);
+            if (event.type === "turn_ended" && event.status === "aborted")
+                abortedTurns.add(id);
+            if (event.type === "agent.rejection")
+                rejections.add(id);
+            if (event.type === "tool_result" && event.error?.code === "user_denied")
+                rejections.add(id);
+        }
+        catch { }
+    }
+    return { interrupts: Math.max(interrupts.size, abortedTurns.size), rejections: rejections.size };
+}

package/dist/packs/codie.js

@@ -0,0 +1,182 @@
+"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.levelToModel = levelToModel;
+exports.mapAgentModel = mapAgentModel;
+exports.codiePackConfig = codiePackConfig;
+exports.mergeCodiePackConfig = mergeCodiePackConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const manifest_1 = require("./manifest");
+const paths_1 = require("./paths");
+const shim_1 = require("./shim");
+const store_1 = require("./store");
+const LEVEL_LABEL = { opus: "Strongest", sonnet: "Balanced", haiku: "Fastest" };
+function newestFirst(a, b) {
+    return b.id.localeCompare(a.id, undefined, { numeric: true });
+}
+function levelToModel(level, catalog) {
+    const key = level.toLowerCase();
+    const tierNames = {
+        opus: ["strongest", "opus", "high", "max"],
+        sonnet: ["balanced", "sonnet", "medium", "default"],
+        haiku: ["fastest", "haiku", "low", "fast"],
+    };
+    const tiered = catalog.filter((m) => [m.tier, m.level].some((t) => typeof t === "string" && tierNames[key].includes(t.toLowerCase())));
+    if (tiered.length)
+        return { model: [...tiered].sort(newestFirst)[0].id, how: "tier" };
+    const family = catalog.filter((m) => new RegExp(`(^|[^a-z])${key}([^a-z]|$)`, "i").test(m.id));
+    if (family.length)
+        return { model: [...family].sort(newestFirst)[0].id, how: "family" };
+    const priced = catalog
+        .filter((m) => m.cost && Number.isFinite(m.cost.input) && Number.isFinite(m.cost.output))
+        .sort((a, b) => a.cost.input + a.cost.output - (b.cost.input + b.cost.output) || a.id.localeCompare(b.id));
+    if (priced.length) {
+        const index = key === "haiku" ? 0 : key === "opus" ? priced.length - 1 : Math.floor((priced.length - 1) / 2);
+        return { model: priced[index].id, how: "price" };
+    }
+    return { how: "none" };
+}
+function mapAgentModel(value, approved, catalog) {
+    const model = (value ?? "").trim();
+    if (!model || model === "inherit")
+        return {};
+    const key = model.toLowerCase();
+    if (LEVEL_LABEL[key]) {
+        const usable = (catalog ?? []).filter((m) => !approved || approved.has(m.id.replace(/^codiedev\//, "")));
+        const picked = levelToModel(key, usable);
+        if (!picked.model) {
+            return { note: `level ${LEVEL_LABEL[key]} (${model}): no matching approved model, using the governed default` };
+        }
+        return { model: picked.model, note: `level ${LEVEL_LABEL[key]} (${model}) → ${picked.model} (by ${picked.how})` };
+    }
+    if (!model.includes("/"))
+        return { note: `unknown level "${model}", using the governed default` };
+    if (approved) {
+        const bare = model.replace(/^codiedev\//, "");
+        if (!approved.has(bare))
+            return { note: `dropped model "${model}" (not approved for this Codiedev account)` };
+    }
+    return { model };
+}
+function codiePackConfig(root, options = {}) {
+    const registry = (0, store_1.readRegistry)(root);
+    const result = { skillPaths: [], agents: {}, plugins: [], notes: [] };
+    for (const [slug, entry] of Object.entries(registry.packs).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!(0, manifest_1.isSafeSegment)(slug) || !Array.isArray(entry.harnesses) || !entry.harnesses.includes("codie"))
+            continue;
+        const dir = typeof entry.dir === "string" ? entry.dir : "";
+        if (!dir || !fs.existsSync(dir))
+            continue;
+        try {
+            const hooks = JSON.parse(fs.readFileSync(path.join(dir, "hooks", "hooks.json"), "utf8"))?.hooks;
+            const skipped = (0, shim_1.unsupportedShimEvents)([{ slug, root: dir, hooks: hooks ?? {} }]).get(slug);
+            if (skipped?.length)
+                result.notes.push(`pack ${slug}: hooks Codie can't run were skipped: ${skipped.join(", ")}`);
+        }
+        catch {
+        }
+        const skills = path.join(dir, "skills");
+        if (fs.existsSync(skills))
+            result.skillPaths.push(skills);
+        const agentsDir = path.join(dir, "agents");
+        let agentFiles = [];
+        try {
+            agentFiles = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md")).sort();
+        }
+        catch {
+            agentFiles = [];
+        }
+        for (const file of agentFiles) {
+            const fallbackName = file.slice(0, -3);
+            let content;
+            try {
+                content = fs.readFileSync(path.join(agentsDir, file), "utf8");
+            }
+            catch {
+                continue;
+            }
+            const { data, body } = (0, manifest_1.parseFrontmatter)(content);
+            const name = (0, manifest_1.isSafeSegment)(data.name) ? data.name : fallbackName;
+            if (result.agents[name]) {
+                result.notes.push(`agent "${name}" from pack ${slug} skipped (already defined by another pack)`);
+                continue;
+            }
+            const mapped = mapAgentModel(data.model, options.approvedModels, options.catalog);
+            if (mapped.note)
+                result.notes.push(`agent "${name}" (${slug}): ${mapped.note}`);
+            result.agents[name] = {
+                description: data.description || `${name} (from starter pack ${slug})`,
+                prompt: body.trim(),
+                mode: "subagent",
+                ...(mapped.model ? { model: mapped.model } : {}),
+            };
+        }
+    }
+    const shim = (0, paths_1.shimPath)(root);
+    const anyCodie = Object.values(registry.packs).some((e) => Array.isArray(e.harnesses) && e.harnesses.includes("codie"));
+    if (anyCodie && fs.existsSync(shim))
+        result.plugins.push((0, url_1.pathToFileURL)(shim).href);
+    return result;
+}
+function mergeCodiePackConfig(existing, packs) {
+    const next = { ...existing };
+    if (packs.skillPaths.length) {
+        const current = existing.skills;
+        const base = Array.isArray(current)
+            ? { paths: current.filter((p) => typeof p === "string") }
+            : current && typeof current === "object"
+                ? { ...current }
+                : {};
+        const paths = Array.isArray(base.paths) ? [...base.paths] : [];
+        for (const p of packs.skillPaths)
+            if (!paths.includes(p))
+                paths.push(p);
+        next.skills = { ...base, paths };
+    }
+    if (Object.keys(packs.agents).length) {
+        const current = existing.agent && typeof existing.agent === "object" ? existing.agent : {};
+        next.agent = { ...packs.agents, ...current };
+    }
+    if (packs.plugins.length) {
+        const current = Array.isArray(existing.plugin) ? [...existing.plugin] : [];
+        for (const p of packs.plugins)
+            if (!current.includes(p))
+                current.push(p);
+        next.plugin = current;
+    }
+    return next;
+}