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

package/dist/piHooks.js

@@ -0,0 +1,216 @@
+"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.PI_CONTEXT_CUSTOM_TYPE = void 0;
+exports.normalizePiTranscript = normalizePiTranscript;
+exports.isPiTranscriptEmpty = isPiTranscriptEmpty;
+exports.piLaunchFromArgv = piLaunchFromArgv;
+exports.piExtensionPath = piExtensionPath;
+exports.inspectPiExtension = inspectPiExtension;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const harnessDirs_1 = require("./harnessDirs");
+exports.PI_CONTEXT_CUSTOM_TYPE = "codiedev";
+const SKILL_EXPANSION = /^<skill name="([^"]{1,200})" location="[^"]*">/;
+const num = (n) => (typeof n === "number" && Number.isFinite(n) ? Math.max(0, n) : 0);
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => (block?.type === "text" && typeof block.text === "string" ? block.text : ""))
+        .filter(Boolean)
+        .join("\n");
+}
+function userBlocks(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((block) => block?.type === "text" && typeof block.text === "string"
+        ? [{ type: "text", text: block.text }]
+        : block?.type === "image" ? [{ type: "text", text: "[image]" }] : []);
+}
+function skillFromPath(value) {
+    if (typeof value !== "string")
+        return null;
+    const m = value.replace(/\\/g, "/").match(/\/([^/]+)\/SKILL\.md$/);
+    return m ? m[1] : null;
+}
+function errorCode(message) {
+    return message.match(/^\s*(\d{3})\b/)?.[1] ?? "";
+}
+function normalizePiTranscript(content) {
+    const out = [];
+    const skillReads = new Map();
+    let errorStreakAt;
+    const push = (record) => out.push(JSON.stringify(record));
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!entry || typeof entry !== "object")
+            continue;
+        const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : undefined;
+        const uuid = typeof entry.id === "string" ? entry.id : undefined;
+        if (entry.type !== "message" || !entry.message || typeof entry.message !== "object")
+            continue;
+        const message = entry.message;
+        if (!(message.role === "assistant" && message.stopReason === "error"))
+            errorStreakAt = undefined;
+        if (message.role === "user") {
+            const text = textOf(message.content);
+            const skill = text.match(SKILL_EXPANSION)?.[1];
+            if (skill)
+                push({ type: "pi.skill_invoked", timestamp, skill });
+            push({ type: "user", uuid, timestamp, message: { role: "user", content: userBlocks(message.content) } });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const blocks = [];
+            for (const block of Array.isArray(message.content) ? message.content : []) {
+                if (block?.type === "text" && typeof block.text === "string")
+                    blocks.push({ type: "text", text: block.text });
+                else if (block?.type === "thinking" && typeof block.thinking === "string")
+                    blocks.push({ type: "thinking", thinking: block.thinking });
+                else if (block?.type === "toolCall") {
+                    const input = block.arguments && typeof block.arguments === "object" ? block.arguments : {};
+                    blocks.push({ type: "tool_use", id: block.id, name: block.name ?? "tool", input });
+                    const skill = block.name === "read" ? skillFromPath(input.path) : null;
+                    if (skill && typeof block.id === "string")
+                        skillReads.set(block.id, skill);
+                }
+            }
+            const usage = message.usage ?? {};
+            const tokens = num(usage.input) + num(usage.output) + num(usage.cacheRead) + num(usage.cacheWrite);
+            const measured = tokens > 0 || message.stopReason !== "error";
+            push({
+                type: "assistant",
+                uuid,
+                timestamp,
+                message: {
+                    id: typeof message.responseId === "string" ? message.responseId : uuid,
+                    role: "assistant",
+                    model: typeof message.model === "string" ? message.model : undefined,
+                    ...(measured ? {
+                        usage: {
+                            input_tokens: num(usage.input),
+                            output_tokens: num(usage.output),
+                            cache_read_input_tokens: num(usage.cacheRead),
+                            cache_creation_input_tokens: num(usage.cacheWrite),
+                        },
+                    } : {}),
+                    content: blocks,
+                },
+            });
+            if (message.stopReason === "aborted") {
+                push({ type: "user", timestamp, message: { role: "user", content: [{ type: "text", text: "[Request interrupted by user]" }] } });
+            }
+            if (message.stopReason === "error" && typeof message.errorMessage === "string") {
+                errorStreakAt ??= typeof message.timestamp === "number" ? new Date(message.timestamp).toISOString() : timestamp;
+                push({
+                    type: "agent.error",
+                    timestamp: errorStreakAt,
+                    data: { errorContext: "model_call", error: { code: errorCode(message.errorMessage), message: message.errorMessage } },
+                });
+            }
+            continue;
+        }
+        if (message.role === "toolResult") {
+            const id = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
+            const skill = id ? skillReads.get(id) : undefined;
+            if (skill && message.isError !== true)
+                push({ type: "pi.skill_invoked", timestamp, skill });
+            push({
+                type: "user",
+                uuid,
+                timestamp,
+                message: {
+                    role: "user",
+                    content: [{ type: "tool_result", tool_use_id: id, content: textOf(message.content), is_error: message.isError === true }],
+                },
+            });
+            continue;
+        }
+        if (message.role === "bashExecution" && typeof message.command === "string") {
+            push({ type: "user", uuid, timestamp, message: { role: "user", content: [{ type: "text", text: `<bash-input>${message.command}</bash-input>` }] } });
+        }
+    }
+    return out.join("\n") + (out.length ? "\n" : "");
+}
+function isPiTranscriptEmpty(content) {
+    return !content.split("\n").some((line) => line.includes('"type":"message"'));
+}
+function piLaunchFromArgv(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-p" || a === "--print")
+            return "pi:print";
+        if (a === "--mode") {
+            const mode = argv[i + 1];
+            if (mode === "json" || mode === "rpc")
+                return `pi:${mode}`;
+        }
+        if (a === "--mode=json" || a === "--mode=rpc")
+            return `pi:${a.slice(7)}`;
+    }
+    return "pi:tui";
+}
+function piExtensionPath(agentDir = (0, harnessDirs_1.piAgentDir)()) {
+    return path.join(agentDir, "extensions", "codiedev.ts");
+}
+function inspectPiExtension(file = piExtensionPath()) {
+    if (!fs.existsSync(file))
+        return { status: "not-installed", detail: `${file} not found` };
+    let source;
+    try {
+        source = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return { status: "fail", detail: `${file} unreadable` };
+    }
+    const expected = ["session-start-pi", "backup-pi", "capture-pi-final"];
+    const missing = expected.filter((subcommand) => !source.includes(JSON.stringify(subcommand)));
+    if (missing.length)
+        return { status: "fail", detail: `missing ${missing.join(", ")} — re-run \`codiedev connect\`` };
+    return { status: "pass", detail: `session start, capture and backup events (${(0, harnessDirs_1.displayPath)(file)})` };
+}

package/dist/piRuntime.js

@@ -0,0 +1,120 @@
+"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.PI_RUNTIME_SPEC = exports.PI_VERSION = exports.PI_PACKAGE = void 0;
+exports.piRuntimeDir = piRuntimeDir;
+exports.installedPiEntry = installedPiEntry;
+exports.ensurePiRuntime = ensurePiRuntime;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const codieRuntimeInstall_1 = require("./codieRuntimeInstall");
+exports.PI_PACKAGE = "@mariozechner/pi-coding-agent";
+exports.PI_VERSION = "0.73.1";
+exports.PI_RUNTIME_SPEC = `${exports.PI_PACKAGE}@${exports.PI_VERSION}`;
+function piRuntimeDir(stateDir) {
+    return path.join(stateDir, "runtime-pi");
+}
+function packageDir(installDir) {
+    return path.join(installDir, "node_modules", ...exports.PI_PACKAGE.split("/"));
+}
+function installedPiEntry(installDir, readFile = (f) => fs.readFileSync(f, "utf8")) {
+    try {
+        const pkg = JSON.parse(readFile(path.join(packageDir(installDir), "package.json")));
+        if (pkg.version !== exports.PI_VERSION)
+            return null;
+        const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.pi;
+        return typeof bin === "string" ? path.join(packageDir(installDir), bin) : null;
+    }
+    catch {
+        return null;
+    }
+}
+const INSTALL_ATTEMPTS = 2;
+const INSTALL_RETRY_DELAY_MS = 5_000;
+function ensurePiRuntime(deps) {
+    const installDir = piRuntimeDir(deps.stateDir);
+    const exists = deps.exists ?? fs.existsSync;
+    const readFile = deps.readFile ?? ((f) => fs.readFileSync(f, "utf8"));
+    const ready = installedPiEntry(installDir, readFile);
+    if (ready && exists(ready))
+        return ready;
+    const remove = deps.remove ?? ((target) => fs.rmSync(target, { recursive: true, force: true }));
+    const rename = deps.rename ?? fs.renameSync;
+    const log = deps.log ?? ((message) => console.error(message));
+    const makeStagingDir = deps.makeStagingDir ?? (() => {
+        fs.mkdirSync(deps.stateDir, { recursive: true });
+        return fs.mkdtempSync(path.join(deps.stateDir, ".runtime-pi-"));
+    });
+    const run = deps.run ?? ((args) => {
+        const result = (0, child_process_1.spawnSync)(process.platform === "win32" ? "npm.cmd" : "npm", args, {
+            encoding: "utf8", stdio: ["ignore", "ignore", "pipe"], shell: process.platform === "win32",
+        });
+        if (result.error)
+            throw result.error;
+        return { status: result.status, stderr: result.stderr ?? "" };
+    });
+    const sleep = deps.sleep ?? ((ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms));
+    log(`Installing pi (${exports.PI_RUNTIME_SPEC}). This runs once, and only for \`codie --pi\`.`);
+    for (let attempt = 1;; attempt++) {
+        const staging = makeStagingDir();
+        try {
+            const result = run((0, codieRuntimeInstall_1.buildRuntimeInstallArgs)(staging, exports.PI_RUNTIME_SPEC));
+            if (result.status !== 0)
+                throw new Error(result.stderr?.trim() || `npm exited with ${result.status}`);
+            const staged = installedPiEntry(staging, readFile);
+            if (!staged || !exists(staged)) {
+                throw new Error(`the install did not produce pi. Check that ${exports.PI_RUNTIME_SPEC} is available from your npm registry.`);
+            }
+            remove(installDir);
+            rename(staging, installDir);
+            break;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (attempt >= INSTALL_ATTEMPTS)
+                throw new Error(`Couldn't install pi: ${message}`);
+            log(`pi install failed (${message.split("\n")[0]}); retrying.`);
+        }
+        finally {
+            remove(staging);
+        }
+        sleep(INSTALL_RETRY_DELAY_MS);
+    }
+    const entry = installedPiEntry(installDir, readFile);
+    if (!entry)
+        throw new Error("Couldn't install pi: the installed package has no CLI entry.");
+    return entry;
+}

package/dist/repoResolver.js

@@ -1,12 +1,4 @@
 "use strict";
-// Pure resolver — given a captured remoteUrl, an optional client-cached
-// repoId, and the company's current repo list, decide which repoId (if any)
-// the session belongs to. Used both inline by the CLI hook and (mirrored
-// in convex/repoResolver.ts) by the /api/captureSession endpoint so that
-// repos added after the user's last `connect` still get matched.
-//
-// "unmatched" is intentional — the backend will accept the session anyway
-// and surface it for triage rather than silently dropping it.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRepoForCapture = resolveRepoForCapture;
 function parseRemoteUrl(url) {
@@ -17,12 +9,6 @@ function parseRemoteUrl(url) {
     if (https) {
         return { host: https[1].toLowerCase(), ownerName: https[2].toLowerCase() };
     }
-    // Codie strips SSH userinfo before putting a remote in the gateway header,
-    // so `git@gitlab.com:owner/repo.git` arrives here as
-    // `gitlab.com:owner/repo.git`. Accept both forms; otherwise every SSH-cloned
-    // Harness checkout loses its repoId even though transcript capture can
-    // resolve the same raw remote correctly. Check this after URL forms so the
-    // colon in `https://` is never mistaken for an SCP separator.
     const scp = s.match(/^(?:[^@\s]+@)?([^:/\s]+):([^/]+\/.+)$/);
     if (scp) {
         return { host: scp[1].toLowerCase(), ownerName: scp[2].toLowerCase() };
@@ -31,11 +17,6 @@ function parseRemoteUrl(url) {
 }
 function resolveRepoForCapture(input) {
     const { remoteUrl, providedRepoId, companyRepos } = input;
-    // The remoteUrl is the ground truth of where the work happened — resolve it
-    // FIRST. A buggy client can send a wrong-but-valid providedRepoId (the Sonifi
-    // case: client matchRepo stamped every session with the org's first repo), so
-    // we must not blindly trust it over the URL. Keep providedRepoId only when it
-    // AGREES with the URL match, or when the URL can't be resolved at all.
     const parsed = remoteUrl ? parseRemoteUrl(remoteUrl) : null;
     const urlMatch = parsed
         ? companyRepos.find((r) => `${r.owner}/${r.name}`.toLowerCase() === parsed.ownerName)

package/dist/secret.js

@@ -1,7 +1,4 @@
 "use strict";
-// Display helpers for credential-shaped strings. Use anywhere a token /
-// secret might end up in user-visible output (logs, success lines, error
-// messages) so a stray `console.log` can't leak the full value.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.maskToken = maskToken;
 const PREFIX_LEN = 12;