@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/dist/shared/artifacts.js

@@ -0,0 +1,96 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { TEMP_ARTIFACTS_DIR } from "./types.js";
+import { getAgentDir } from "./utils.js";
+import { ensureSafeTempPath } from "./temp-root.js";
+const CLEANUP_MARKER_FILE = ".last-cleanup";
+export const ARTIFACT_CLEANUP_DAYS = 7;
+export function getArtifactsDir(sessionFile) {
+    if (sessionFile) {
+        const sessionDir = path.dirname(sessionFile);
+        return path.join(sessionDir, "subagent-artifacts");
+    }
+    return TEMP_ARTIFACTS_DIR;
+}
+export function getArtifactPaths(artifactsDir, runId, agent, index) {
+    ensureSafeTempPath(artifactsDir);
+    const suffix = index !== undefined ? `_${index}` : "";
+    const safeAgent = agent.replace(/[^\w.-]/g, "_").slice(0, 128);
+    const base = `${runId}_${safeAgent}${suffix}`;
+    return {
+        inputPath: path.join(artifactsDir, `${base}_input.md`),
+        outputPath: path.join(artifactsDir, `${base}_output.md`),
+        metadataPath: path.join(artifactsDir, `${base}_meta.json`),
+    };
+}
+export function appendJsonl(filePath, line) {
+    fs.appendFileSync(filePath, `${line}\n`);
+}
+export async function cleanupOldArtifacts(dir, maxAgeDays) {
+    ensureSafeTempPath(dir);
+    try {
+        await fs.promises.access(dir);
+    }
+    catch {
+        return;
+    }
+    const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
+    const now = Date.now();
+    try {
+        const stat = await fs.promises.lstat(markerPath);
+        if (!stat.isSymbolicLink() && now - stat.mtimeMs < 24 * 60 * 60 * 1000)
+            return;
+        await fs.promises.unlink(markerPath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return;
+    }
+    const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+    const cutoff = now - maxAgeMs;
+    for (const file of await fs.promises.readdir(dir)) {
+        if (file === CLEANUP_MARKER_FILE)
+            continue;
+        const filePath = path.join(dir, file);
+        try {
+            const stat = await fs.promises.lstat(filePath);
+            if (stat.mtimeMs < cutoff) {
+                await fs.promises.unlink(filePath);
+            }
+        }
+        catch {
+            // Artifact cleanup is best-effort housekeeping. Skip files that disappear
+            // or become unreadable while scanning so one bad entry does not block the rest.
+        }
+    }
+    try {
+        await fs.promises.writeFile(markerPath, String(now), { flag: "wx", mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+export async function cleanupAllArtifactDirs(maxAgeDays) {
+    await cleanupOldArtifacts(TEMP_ARTIFACTS_DIR, maxAgeDays);
+    const sessionsBase = path.join(getAgentDir(), "sessions");
+    let dirs;
+    try {
+        dirs = await fs.promises.readdir(sessionsBase);
+    }
+    catch {
+        // Session artifact cleanup is best-effort. If the sessions root cannot be read,
+        // skip cleanup instead of failing extension startup.
+        return;
+    }
+    for (const dir of dirs) {
+        const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
+        try {
+            await cleanupOldArtifacts(artifactsDir, maxAgeDays);
+        }
+        catch {
+            // Session cleanup is best-effort. Keep going so one unreadable session dir
+            // does not block cleanup for the rest.
+        }
+    }
+}

package/dist/shared/atomic-json.js

@@ -0,0 +1,13 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function writeAtomicJson(filePath, payload) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
+    try {
+        fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), { encoding: "utf-8", mode: 0o600 });
+        fs.renameSync(tempPath, filePath);
+    }
+    finally {
+        fs.rmSync(tempPath, { force: true });
+    }
+}

package/dist/shared/cooperative.js

@@ -0,0 +1,20 @@
+import { setImmediate as yieldToInput } from "node:timers/promises";
+export function runSynchronously(steps) {
+    let step = steps.next();
+    while (!step.done)
+        step = steps.next();
+    return step.value;
+}
+/** Batched recovery and delivery leave room for input between records. */
+export async function runCooperatively(steps) {
+    let step = steps.next();
+    for (let count = 0; !step.done; step = steps.next()) {
+        // ponytail: one recovery record remains atomic; move a demonstrated
+        // single-record stall off-thread rather than increasing this batch size.
+        if (++count === 32) {
+            await yieldToInput();
+            count = 0;
+        }
+    }
+    return step.value;
+}

package/dist/shared/execution-cwd.js

@@ -0,0 +1,14 @@
+import { hasExecutionCwdOwner } from "../runs/shared/child-execution-cwd.js";
+/** Capture the active directory owner once per invocation, before asynchronous preparation. */
+export function resolveExecutionCwd(pi, ctx) {
+    const request = { sessionManager: ctx.sessionManager };
+    pi.events.emit("pi-change-working-dir:resolve-execution-cwd", request);
+    if (request.result?.error)
+        throw new Error(request.result.error);
+    if (request.result && !request.result.cwd)
+        throw new Error("Working-directory owner did not return an execution directory.");
+    if (!request.result && pi.getAllTools && pi.getCommands && hasExecutionCwdOwner({ getAllTools: pi.getAllTools, getCommands: pi.getCommands })) {
+        throw new Error("The loaded directory extension did not resolve the execution directory. Update pi-change-working-dir before delegating work.");
+    }
+    return request.result?.cwd ?? ctx.cwd;
+}

package/dist/shared/file-coalescer.js

@@ -0,0 +1,21 @@
+export function createFileCoalescer(handler, defaultDelayMs) {
+    const pending = new Map();
+    return {
+        schedule(file, delayMs = defaultDelayMs) {
+            if (pending.has(file))
+                return false;
+            const timer = setTimeout(() => {
+                pending.delete(file);
+                handler(file);
+            }, delayMs);
+            pending.set(file, timer);
+            return true;
+        },
+        clear() {
+            for (const timer of pending.values()) {
+                clearTimeout(timer);
+            }
+            pending.clear();
+        },
+    };
+}

package/dist/shared/fork-context.js

@@ -0,0 +1,49 @@
+import * as fs from "node:fs";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { requestChildExecutionCwd } from "../runs/shared/child-execution-cwd.js";
+export function resolveSubagentContext(value) {
+    return value === "fork" ? "fork" : "fresh";
+}
+export function createForkContextResolver(sessionManager, requestedContext) {
+    if (resolveSubagentContext(requestedContext) !== "fork") {
+        return {
+            sessionFileForIndex: () => undefined,
+        };
+    }
+    const parentSessionFile = sessionManager.getSessionFile();
+    if (!parentSessionFile) {
+        throw new Error("Forked subagent context requires a persisted parent session.");
+    }
+    const leafId = sessionManager.getLeafId();
+    if (!leafId) {
+        throw new Error("Forked subagent context requires a current leaf to fork from.");
+    }
+    const sessionDir = sessionManager.getSessionDir();
+    const cachedSessionFiles = new Map();
+    return {
+        sessionFileForIndex(index = 0) {
+            const cached = cachedSessionFiles.get(index);
+            if (cached)
+                return cached;
+            try {
+                if (!fs.existsSync(parentSessionFile)) {
+                    throw new Error(`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`);
+                }
+                const sessionFile = SessionManager.open(parentSessionFile, sessionDir).createBranchedSession(leafId);
+                if (!sessionFile) {
+                    throw new Error("Session manager did not return a forked session file.");
+                }
+                if (!fs.existsSync(sessionFile)) {
+                    throw new Error(`Session manager returned a forked session file that does not exist: ${sessionFile}`);
+                }
+                requestChildExecutionCwd(sessionFile);
+                cachedSessionFiles.set(index, sessionFile);
+                return sessionFile;
+            }
+            catch (error) {
+                const cause = error instanceof Error ? error : new Error(String(error));
+                throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
+            }
+        },
+    };
+}

package/dist/shared/formatters.js

@@ -0,0 +1,85 @@
+/**
+ * Formatting utilities for display output
+ */
+import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.js";
+/**
+ * Format token count with k suffix for large numbers
+ */
+export function formatTokens(n) {
+    return n < 1000 ? String(n) : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
+}
+export function formatModelThinking(model, thinking) {
+    const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
+    const displayModel = parsed?.baseModel ?? model;
+    const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
+    const displayThinking = parsed?.thinkingSuffix ? parsed.thinkingSuffix.slice(1) : explicitThinking;
+    return [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean).join(" · ");
+}
+/**
+ * Format usage statistics into a compact string
+ */
+export function formatUsage(u, model) {
+    const parts = [];
+    if (u.turns)
+        parts.push(`${u.turns} turn${u.turns > 1 ? "s" : ""}`);
+    if (u.input)
+        parts.push(`in:${formatTokens(u.input)}`);
+    if (u.output)
+        parts.push(`out:${formatTokens(u.output)}`);
+    if (u.cacheRead)
+        parts.push(`R${formatTokens(u.cacheRead)}`);
+    if (u.cacheWrite)
+        parts.push(`W${formatTokens(u.cacheWrite)}`);
+    if (u.cost)
+        parts.push(`$${u.cost.toFixed(4)}`);
+    if (model)
+        parts.push(model);
+    return parts.join(" ");
+}
+/**
+ * Format duration in human-readable form
+ */
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
+}
+/**
+ * Format a tool call for display
+ */
+export function formatToolCall(name, args, expanded = false) {
+    switch (name) {
+        case "bash": {
+            const command = typeof args.command === "string" ? args.command : "";
+            const maxLength = expanded ? 240 : 60;
+            return `$ ${command.slice(0, maxLength)}${command.length > maxLength ? "..." : ""}`;
+        }
+        case "read":
+        case "write":
+        case "edit": {
+            const target = typeof args.path === "string"
+                ? args.path
+                : typeof args.file_path === "string"
+                    ? args.file_path
+                    : "";
+            return `${name} ${shortenPath(target)}`;
+        }
+        default: {
+            const s = JSON.stringify(args);
+            const maxLength = expanded ? 160 : 40;
+            return `${name} ${s.slice(0, maxLength)}${s.length > maxLength ? "..." : ""}`;
+        }
+    }
+}
+/**
+ * Shorten a path by replacing home directory with ~
+ */
+export function shortenPath(p) {
+    const home = process.env.HOME;
+    if (home && p.startsWith(home)) {
+        return `~${p.slice(home.length)}`;
+    }
+    return p;
+}