codiedev 0.10.0-beta.1 → 0.10.0-beta.11

package/dist/selfUpdate.js

@@ -0,0 +1,376 @@
+"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.BIN_NAMES = void 0;
+exports.planSelfUpdate = planSelfUpdate;
+exports.isSelfUpdateDue = isSelfUpdateDue;
+exports.readSelfUpdateState = readSelfUpdateState;
+exports.maybeSpawnSelfUpdate = maybeSpawnSelfUpdate;
+exports.maybeRefreshInstructions = maybeRefreshInstructions;
+exports.missingPs1Shims = missingPs1Shims;
+exports.findInstalledHookScript = findInstalledHookScript;
+exports.runSelfUpdate = runSelfUpdate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const version_1 = require("./version");
+const versionCheck_1 = require("./versionCheck");
+const configDir_1 = require("./configDir");
+const captureLog_1 = require("./captureLog");
+const launcher_1 = require("./launcher");
+const utils_1 = require("./utils");
+const PKG = "codiedev";
+const SELF_UPDATE_INTERVAL_MS = 2 * 60 * 60 * 1000;
+const LOCK_STALE_MS = 10 * 60 * 1000;
+const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 5_000;
+function planSelfUpdate(deps) {
+    const { env } = deps;
+    if (env.CODIEDEV_NO_UPDATE_CHECK || env.CODIEDEV_NO_AUTO_UPDATE) {
+        return { kind: "skip", reason: "disabled" };
+    }
+    if (env.CI || env.CONTINUOUS_INTEGRATION || env.GITHUB_ACTIONS || env.BUILD_NUMBER) {
+        return { kind: "skip", reason: "ci" };
+    }
+    if (deps.isContainer)
+        return { kind: "skip", reason: "container" };
+    const p = deps.hookScriptReal.replace(/\\/g, "/");
+    if (/\/(?:_npx|\.npm\/_npx)\//.test(p))
+        return { kind: "skip", reason: "npx" };
+    const pkgDir = path.dirname(path.dirname(deps.hookScriptReal));
+    if (!deps.isWritable(pkgDir))
+        return { kind: "skip", reason: "readonly" };
+    if (/\/\.pnpm\/|\/pnpm\/global\/|\/global\/v\d+\/[^/]+\/node_modules\/codiedev\/|\/store\/v\d+\/links\//.test(p)) {
+        return deps.viaLauncher ? { kind: "pnpm" } : { kind: "skip", reason: "pnpm-direct" };
+    }
+    if (/\/install\/global\/node_modules\/codiedev\/dist\/hook\.js$/.test(p))
+        return { kind: "bun" };
+    const unix = p.match(/^(.*)\/lib\/node_modules\/codiedev\/dist\/hook\.js$/);
+    if (unix && deps.platform !== "win32")
+        return { kind: "npm", prefix: unix[1] };
+    const win = p.match(/^(.*)\/node_modules\/codiedev\/dist\/hook\.js$/);
+    if (win && deps.platform === "win32")
+        return { kind: "npm", prefix: win[1] };
+    return { kind: "skip", reason: "unmanaged" };
+}
+function isSelfUpdateDue(state, nowMs) {
+    return !state || nowMs - state.lastAttemptAt > SELF_UPDATE_INTERVAL_MS;
+}
+function statePath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), ".self-update.json");
+}
+function lockPath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), ".self-update.lock");
+}
+function readSelfUpdateState() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(statePath(), "utf8"));
+        return typeof parsed.lastAttemptAt === "number" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeState(state) {
+    try {
+        fs.mkdirSync((0, configDir_1.codiedevStateDir)(), { recursive: true });
+        fs.writeFileSync(statePath(), JSON.stringify(state), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function maybeSpawnSelfUpdate(hookEntry) {
+    try {
+        if (!hookEntry || process.env.CODIEDEV_NO_AUTO_UPDATE || process.env.CODIEDEV_NO_UPDATE_CHECK)
+            return;
+        const now = Date.now();
+        if (!isSelfUpdateDue(readSelfUpdateState(), now))
+            return;
+        if (!writeState({ lastAttemptAt: now, lastResult: "spawned" }))
+            return;
+        const child = (0, child_process_1.spawn)(process.execPath, [hookEntry, "self-update"], {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        child.unref();
+    }
+    catch {
+    }
+}
+function instructionsVersionPath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), ".instructions-version");
+}
+function maybeRefreshInstructions(refresh = utils_1.refreshInstalledInstructions) {
+    if (process.env.CODIEDEV_NO_AUTO_UPDATE || process.env.CODIEDEV_NO_UPDATE_CHECK)
+        return;
+    try {
+        const marker = instructionsVersionPath();
+        try {
+            if (fs.readFileSync(marker, "utf8").trim() === version_1.CLI_VERSION)
+                return;
+        }
+        catch {
+        }
+        const refreshed = refresh();
+        fs.mkdirSync((0, configDir_1.codiedevStateDir)(), { recursive: true });
+        fs.writeFileSync(marker, version_1.CLI_VERSION, "utf8");
+        if (refreshed.length > 0) {
+            (0, captureLog_1.appendCaptureLog)({
+                stage: "self-update",
+                sessionId: undefined,
+                outcome: "ok",
+                detail: `result=instructions-refreshed version=${version_1.CLI_VERSION} files=${refreshed.length}`,
+            });
+        }
+    }
+    catch {
+    }
+}
+function acquireLock() {
+    const lock = lockPath();
+    try {
+        fs.mkdirSync(lock);
+        return true;
+    }
+    catch {
+        try {
+            if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) {
+                fs.rmSync(lock, { recursive: true, force: true });
+                fs.mkdirSync(lock);
+                return true;
+            }
+        }
+        catch {
+        }
+        return false;
+    }
+}
+function detectContainer(env) {
+    if (env.KUBERNETES_SERVICE_HOST)
+        return true;
+    if (fs.existsSync("/.dockerenv") || fs.existsSync("/run/.containerenv"))
+        return true;
+    try {
+        return /docker|containerd|kubepods|lxc/.test(fs.readFileSync("/proc/1/cgroup", "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+function registryBase(env) {
+    const configured = env.npm_config_registry || env.NPM_CONFIG_REGISTRY;
+    return (configured || "https://registry.npmjs.org").replace(/\/+$/, "");
+}
+async function fetchLatest(env) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${registryBase(env)}/${PKG}/latest`, {
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return null;
+        const json = (await res.json());
+        return typeof json.version === "string" ? json.version : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function installCommand(plan, version, env) {
+    const spec = `${PKG}@${version}`;
+    const configured = env.npm_config_registry || env.NPM_CONFIG_REGISTRY;
+    const registry = configured ? ["--registry", registryBase(env)] : [];
+    switch (plan.kind) {
+        case "npm": {
+            const args = ["i", "-g", "--prefix", plan.prefix, "--no-fund", "--no-audit", ...registry, spec];
+            const execDir = path.dirname(process.execPath);
+            const npmCli = [
+                path.join(execDir, "node_modules", "npm", "bin", "npm-cli.js"),
+                path.join(execDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+            ].find((p) => fs.existsSync(p));
+            if (npmCli)
+                return { cmd: process.execPath, args: [npmCli, ...args] };
+            return { cmd: process.platform === "win32" ? "npm.cmd" : "npm", args, shell: process.platform === "win32" };
+        }
+        case "pnpm":
+            return { cmd: "pnpm", args: ["add", "-g", ...registry, spec], shell: process.platform === "win32" };
+        case "bun":
+            return { cmd: "bun", args: ["add", "-g", ...registry, spec] };
+        default:
+            return null;
+    }
+}
+exports.BIN_NAMES = ["codiedev", "codiedev-hook", "codie"];
+function missingPs1Shims(prefix, exists = fs.existsSync) {
+    return exports.BIN_NAMES.map((name) => path.join(prefix, `${name}.ps1`)).filter((p) => !exists(p));
+}
+function readVersionAt(hookScript) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(path.dirname(path.dirname(hookScript)), "package.json"), "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+function findInstalledHookScript(plan, hookEntry, version, pnpmRoot = pnpmGlobalRoot) {
+    if (plan.kind !== "pnpm")
+        return readVersionAt(hookEntry) === version ? hookEntry : null;
+    const root = pnpmRoot();
+    if (!root)
+        return null;
+    const candidates = [path.join(root, PKG, "dist", "hook.js")];
+    try {
+        for (const entry of fs.readdirSync(root)) {
+            candidates.push(path.join(root, entry, "node_modules", PKG, "dist", "hook.js"));
+        }
+    }
+    catch {
+    }
+    for (const candidate of candidates) {
+        if (readVersionAt(candidate) !== version)
+            continue;
+        try {
+            return fs.realpathSync(candidate);
+        }
+        catch {
+        }
+    }
+    return null;
+}
+function pnpmGlobalRoot() {
+    const root = (0, child_process_1.spawnSync)("pnpm", ["root", "-g"], {
+        encoding: "utf8",
+        timeout: 30_000,
+        shell: process.platform === "win32",
+        windowsHide: true,
+    });
+    const dir = root.status === 0 ? root.stdout.trim() : "";
+    return dir || null;
+}
+async function runSelfUpdate(hookEntry) {
+    const env = process.env;
+    const now = Date.now();
+    const finish = (lastResult, extra = {}) => {
+        const state = { lastAttemptAt: now, lastResult, fromVersion: version_1.CLI_VERSION, ...extra };
+        writeState(state);
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "self-update",
+            sessionId: undefined,
+            outcome: lastResult.startsWith("error") ? "ERROR" : "ok",
+            detail: `result=${lastResult} from=${version_1.CLI_VERSION} to=${extra.toVersion ?? "-"} elapsedMs=${Date.now() - now}`,
+        });
+        return state;
+    };
+    let hookScriptReal;
+    try {
+        hookScriptReal = fs.realpathSync(hookEntry);
+    }
+    catch {
+        return finish("skip:unresolved");
+    }
+    const plan = planSelfUpdate({
+        hookScriptReal,
+        env,
+        platform: process.platform,
+        isContainer: detectContainer(env),
+        viaLauncher: Boolean(env.CODIEDEV_VIA_LAUNCHER),
+        isWritable: (dir) => {
+            try {
+                fs.accessSync(dir, fs.constants.W_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    });
+    if (plan.kind === "skip")
+        return finish(`skip:${plan.reason}`);
+    if (!acquireLock()) {
+        (0, captureLog_1.appendCaptureLog)({ stage: "self-update", sessionId: undefined, outcome: "ok", detail: "result=skip:locked" });
+        return { lastAttemptAt: now, lastResult: "skip:locked" };
+    }
+    try {
+        const latest = await fetchLatest(env);
+        if (!latest)
+            return finish("error:registry");
+        if ((0, versionCheck_1.compareSemver)(version_1.CLI_VERSION, latest) !== -1)
+            return finish("current", { toVersion: latest });
+        const install = installCommand(plan, latest, env);
+        if (!install)
+            return finish("skip:no-installer");
+        const droppedShims = plan.kind === "npm" && process.platform === "win32" ? missingPs1Shims(plan.prefix) : [];
+        const result = (0, child_process_1.spawnSync)(install.cmd, install.args, {
+            stdio: "ignore",
+            timeout: INSTALL_TIMEOUT_MS,
+            env: { ...env, CODIEDEV_NO_AUTO_UPDATE: "1" },
+            shell: install.shell ?? false,
+            windowsHide: true,
+        });
+        if (result.error || result.status !== 0) {
+            return finish(`error:install-exit-${result.status ?? "spawn"}`, { toVersion: latest });
+        }
+        for (const shim of droppedShims) {
+            try {
+                fs.rmSync(shim, { force: true });
+            }
+            catch {
+            }
+        }
+        const installed = findInstalledHookScript(plan, hookScriptReal, latest);
+        if (!installed) {
+            return finish("error:not-found-after-install", { toVersion: latest });
+        }
+        if (!(0, launcher_1.recordCurrentInstall)(installed))
+            return finish("error:record", { toVersion: latest });
+        return finish("updated", { toVersion: latest });
+    }
+    finally {
+        try {
+            fs.rmSync(lockPath(), { recursive: true, force: true });
+        }
+        catch {
+        }
+    }
+}

package/dist/skillMarker.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeSkill = looksLikeSkill;
+exports.stripSkillMarker = stripSkillMarker;
+exports.stampSkillMarker = stampSkillMarker;
+const ID = /^[a-z0-9]{16,64}$/i;
+const LINE = /^[ \t]*<!--\s*codiedev:artifact=[a-z0-9]+\s*-->[ \t]*(?:\r?\n|$)/gim;
+function looksLikeSkill(markdown) {
+    const fm = markdown.match(/^?---\r?\n([\s\S]*?)\r?\n---/);
+    if (!fm)
+        return false;
+    return /^name\s*:/im.test(fm[1]) && /^description\s*:/im.test(fm[1]);
+}
+function stripSkillMarker(markdown) {
+    return markdown.replace(LINE, "");
+}
+function stampSkillMarker(markdown, artifactId) {
+    if (!artifactId || !ID.test(artifactId))
+        return markdown;
+    const body = stripSkillMarker(markdown);
+    const sep = body.endsWith("\n") ? "" : "\n";
+    return `${body}${sep}<!-- codiedev:artifact=${artifactId} -->\n`;
+}

package/dist/subagents.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBAGENT_LIMITS = void 0;
+exports.subagentDir = subagentDir;
+exports.readSubagentTranscripts = readSubagentTranscripts;
+exports.foldSubagentSignals = foldSubagentSignals;
+exports.foldSubagentModelUsage = foldSubagentModelUsage;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const captureSignals_1 = require("./captureSignals");
+const transcriptModels_1 = require("./transcriptModels");
+exports.SUBAGENT_LIMITS = { files: 20, bytes: 20 * 1024 * 1024 };
+function subagentDir(transcriptPath, sessionId) {
+    const dir = node_path_1.default.dirname(transcriptPath);
+    const id = sessionId || node_path_1.default.basename(transcriptPath).replace(/\.jsonl$/i, "");
+    return node_path_1.default.join(dir, id, "subagents");
+}
+function readSubagentTranscripts(transcriptPath, sessionId, limits = exports.SUBAGENT_LIMITS) {
+    const dir = subagentDir(transcriptPath, sessionId);
+    let names;
+    try {
+        names = node_fs_1.default.readdirSync(dir).filter((n) => /^agent-[^/]+\.jsonl$/.test(n));
+    }
+    catch {
+        return { contents: [], count: 0, truncated: false };
+    }
+    const files = names
+        .map((n) => {
+        const full = node_path_1.default.join(dir, n);
+        try {
+            const st = node_fs_1.default.statSync(full);
+            return st.isFile() ? { full, size: st.size, mtime: st.mtimeMs } : null;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((f) => f !== null)
+        .sort((a, b) => a.mtime - b.mtime || a.full.localeCompare(b.full));
+    const contents = [];
+    let bytes = 0;
+    let truncated = false;
+    for (const f of files) {
+        if (contents.length >= limits.files || bytes + f.size > limits.bytes) {
+            truncated = true;
+            break;
+        }
+        try {
+            contents.push(node_fs_1.default.readFileSync(f.full, "utf8"));
+            bytes += f.size;
+        }
+        catch {
+            truncated = true;
+        }
+    }
+    return { contents, count: files.length, truncated };
+}
+function foldSubagentSignals(parent, subs, source) {
+    if (subs.count === 0)
+        return parent;
+    const counts = new Map();
+    const add = (list, fallback) => {
+        for (const c of list ?? fallback.map((skill) => ({ skill, count: 1 })))
+            counts.set(c.skill, (counts.get(c.skill) ?? 0) + c.count);
+    };
+    add(parent.skillInvocationCounts, parent.skillInvocations);
+    const invocations = new Set(parent.skillInvocations);
+    const pulls = new Set(parent.skillPulls);
+    const tools = new Map(parent.toolCalls.map((t) => [t.name, t.calls]));
+    const artifacts = new Map((parent.skillInvocationArtifacts ?? []).map((a) => [a.skill, a.artifactId]));
+    let truncated = parent.truncated;
+    for (const content of subs.contents) {
+        const s = (0, captureSignals_1.parseCaptureSignals)(content, source);
+        add(s.skillInvocationCounts, s.skillInvocations);
+        for (const a of s.skillInvocationArtifacts ?? [])
+            if (!artifacts.has(a.skill))
+                artifacts.set(a.skill, a.artifactId);
+        for (const k of s.skillInvocations)
+            invocations.add(k);
+        for (const k of s.skillPulls)
+            pulls.add(k);
+        for (const t of s.toolCalls)
+            tools.set(t.name, (tools.get(t.name) ?? 0) + t.calls);
+        truncated ||= s.truncated;
+    }
+    const cap = (xs) => {
+        if (xs.length > 100)
+            truncated = true;
+        return xs.slice(0, 100);
+    };
+    return {
+        ...parent,
+        skillInvocations: cap([...invocations].sort()),
+        skillInvocationCounts: cap([...counts].map(([skill, count]) => ({ skill, count: Math.min(count, 10_000) })).sort((a, b) => a.skill.localeCompare(b.skill))),
+        ...(artifacts.size
+            ? { skillInvocationArtifacts: cap([...artifacts].map(([skill, artifactId]) => ({ skill, artifactId })).sort((a, b) => a.skill.localeCompare(b.skill))) }
+            : {}),
+        skillPulls: cap([...pulls].sort()),
+        toolCalls: cap([...tools].map(([name, calls]) => ({ name, calls })).sort((a, b) => a.name.localeCompare(b.name))),
+        subagents: { count: subs.count, truncated: subs.truncated },
+        truncated,
+    };
+}
+function foldSubagentModelUsage(parent, subs, source) {
+    if (subs.contents.length === 0)
+        return parent;
+    const byModel = new Map();
+    const add = (u) => {
+        const cur = byModel.get(u.model);
+        if (!cur) {
+            byModel.set(u.model, { ...u });
+            return;
+        }
+        cur.requests += u.requests;
+        cur.inputTokens += u.inputTokens;
+        cur.outputTokens += u.outputTokens;
+        cur.cacheReadTokens += u.cacheReadTokens;
+        cur.cacheCreationTokens += u.cacheCreationTokens;
+        if (u.costUsd !== undefined)
+            cur.costUsd = (cur.costUsd ?? 0) + u.costUsd;
+        if (u.reportedCostUsd !== undefined)
+            cur.reportedCostUsd = (cur.reportedCostUsd ?? 0) + u.reportedCostUsd;
+        if (u.reasoningTokens !== undefined)
+            cur.reasoningTokens = (cur.reasoningTokens ?? 0) + u.reasoningTokens;
+    };
+    for (const u of parent)
+        add(u);
+    for (const content of subs.contents)
+        for (const u of (0, transcriptModels_1.parseTranscriptModels)(content, source))
+            add(u);
+    return [...byModel.values()].slice(0, 64);
+}

package/dist/teamSkillContext.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEAM_SKILL_CONTEXT = void 0;
+exports.teamSkillSessionOutput = teamSkillSessionOutput;
+exports.TEAM_SKILL_CONTEXT = `This machine is connected to Codiedev, the team's artifact and skill library.
+Before a substantial coding task, run codiedev search "<brief task description>" and reuse a relevant team skill by running codiedev pull <exact-key> and following its instructions. If no skill fits, continue the task.
+Use codiedev push <file.md> to share an artifact when asked, codiedev ask "<question>" for team knowledge, and codiedev inbox to check messages. Use codiedev --help for other commands. If codiedev is unavailable, use npx codiedev@latest.`;
+function teamSkillSessionOutput(source, context = exports.TEAM_SKILL_CONTEXT) {
+    return source === "cursor" ? { additional_context: context } : { additionalContext: context };
+}