@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/shared/artifacts.js

@@ -1,114 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { TEMP_ARTIFACTS_DIR } from "./types.js";
-import { getAgentDir } from "./agent-dir.js";
-import { ensureSafeTempPath } from "./temp-root.js";
-import { hasErrorCode } from "./unknown.js";
-const CLEANUP_MARKER_FILE = ".last-cleanup";
-export const ARTIFACT_CLEANUP_DAYS = 7;
-export function getArtifactsDir(sessionFile) {
-    if (sessionFile !== null && 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`);
-}
-async function claimCleanup(dir, now) {
-    try {
-        await fs.promises.access(dir);
-    }
-    catch {
-        return false;
-    }
-    const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
-    try {
-        const stat = await fs.promises.lstat(markerPath);
-        if (!stat.isSymbolicLink() && now - stat.mtimeMs < 24 * 60 * 60 * 1000) {
-            return false;
-        }
-        await fs.promises.unlink(markerPath);
-    }
-    catch (error) {
-        if (!hasErrorCode(error, "ENOENT")) {
-            return false;
-        }
-    }
-    return true;
-}
-export async function cleanupOldArtifacts(dir, maxAgeDays) {
-    ensureSafeTempPath(dir);
-    const now = Date.now();
-    if (!(await claimCleanup(dir, now))) {
-        return;
-    }
-    const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
-    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 {
-            // Process one filesystem entry at a time to keep cleanup's I/O bounded.
-            // oxlint-disable-next-line no-await-in-loop
-            const stat = await fs.promises.lstat(filePath);
-            if (stat.mtimeMs < cutoff) {
-                // Finish deleting this entry before inspecting the next artifact.
-                // oxlint-disable-next-line no-await-in-loop
-                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 (!hasErrorCode(error, "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 {
-            // Finish each session directory before starting another retention scan.
-            // oxlint-disable-next-line no-await-in-loop
-            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

@@ -1,16 +0,0 @@
-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/chain-files.js

@@ -1,72 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { CHAIN_RUNS_DIR } from "./types.js";
-import { ensureSafeTempPath, ensureTempRoot } from "./temp-root.js";
-const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000;
-const INITIAL_PROGRESS_CONTENT = "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
-export function createChainDir(runId, baseDir, cwd = process.cwd()) {
-    const customBase = baseDir !== undefined && baseDir.length > 0;
-    if (!customBase) {
-        ensureTempRoot();
-    }
-    const chainDir = path.join(customBase ? path.resolve(cwd, baseDir) : CHAIN_RUNS_DIR, runId);
-    if (!customBase) {
-        ensureSafeTempPath(chainDir);
-    }
-    fs.mkdirSync(chainDir, { recursive: true });
-    return chainDir;
-}
-export function removeChainDir(chainDir) {
-    try {
-        fs.rmSync(chainDir, { recursive: true });
-    }
-    catch {
-        // Cleanup is best effort; another run may already have removed the directory.
-    }
-}
-async function cleanupOldDirectory(dir, now) {
-    try {
-        const dirPath = path.join(CHAIN_RUNS_DIR, dir);
-        const stat = await fs.promises.lstat(dirPath);
-        if (stat.isDirectory() && now - stat.mtimeMs > CHAIN_DIR_MAX_AGE_MS) {
-            await fs.promises.rm(dirPath, { recursive: true });
-        }
-    }
-    catch {
-        // One unreadable directory must not prevent cleanup of the remaining runs.
-    }
-}
-export async function cleanupOldChainDirs() {
-    ensureSafeTempPath(CHAIN_RUNS_DIR);
-    const now = Date.now();
-    let dirs;
-    try {
-        dirs = await fs.promises.readdir(CHAIN_RUNS_DIR);
-    }
-    catch {
-        // An unreadable scoped temp root must not fail extension startup.
-        return;
-    }
-    for (const dir of dirs) {
-        // Preserve the existing one-directory resource bound throughout startup pruning.
-        // oxlint-disable-next-line no-await-in-loop
-        await cleanupOldDirectory(dir, now);
-    }
-}
-export function writeInitialProgressFile(progressDir) {
-    fs.mkdirSync(progressDir, { recursive: true });
-    try {
-        fs.writeFileSync(path.join(progressDir, "progress.md"), INITIAL_PROGRESS_CONTENT, {
-            encoding: "utf-8",
-            flag: "wx",
-        });
-    }
-    catch (error) {
-        if (typeof error !== "object" ||
-            error === null ||
-            !("code" in error) ||
-            error.code !== "EEXIST") {
-            throw error;
-        }
-    }
-}

package/dist/shared/concurrency.js

@@ -1,18 +0,0 @@
-/** A bounded worker pool. Results retain input order even when workers finish out of order. */
-export async function mapConcurrent(items, limit, fn) {
-    const integralLimit = Math.floor(limit);
-    const safeLimit = Math.max(1, Number.isNaN(integralLimit) || integralLimit === 0 ? 1 : integralLimit);
-    const results = [];
-    results.length = items.length;
-    let next = 0;
-    async function worker() {
-        while (next < items.length) {
-            const index = next++;
-            // Each worker awaits its own task before claiming another, bounding active work.
-            // oxlint-disable-next-line no-await-in-loop
-            results[index] = await fn(items[index], index);
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, () => worker()));
-    return results;
-}

package/dist/shared/content-preview.js

@@ -1,115 +0,0 @@
-import { isRecord, isUnknownArray } from "./unknown.js";
-function truncate(value, length) {
-    return value.length > length ? `${value.slice(0, length - 3)}...` : value;
-}
-function scalar(value) {
-    if (typeof value === "string" && value.trim().length > 0) {
-        return value;
-    }
-    if (typeof value === "number" || typeof value === "boolean") {
-        return String(value);
-    }
-    return undefined;
-}
-function array(value) {
-    if (!isUnknownArray(value) || value.length === 0) {
-        return undefined;
-    }
-    const first = scalar(value[0]);
-    if (first === undefined || first === "") {
-        return undefined;
-    }
-    return `${first}${value.length > 1 ? ` (+${value.length - 1} more)` : ""}`;
-}
-function mcpPreview(args) {
-    if (typeof args.tool === "string" && args.tool !== "") {
-        const server = typeof args.server === "string" && args.server !== "" ? `${args.server}/` : "";
-        const toolArgs = typeof args.args === "string" && args.args !== "" ? ` ${args.args.slice(0, 40)}` : "";
-        return `${server}${args.tool}${toolArgs}`;
-    }
-    return undefined;
-}
-function primaryPreview(args) {
-    const mcp = mcpPreview(args);
-    if (mcp !== undefined) {
-        return mcp;
-    }
-    const queries = array(args.queries);
-    if (queries !== undefined) {
-        return truncate(queries, 60);
-    }
-    if (typeof args.query === "string" && args.query.trim().length > 0) {
-        return truncate(args.query, 60);
-    }
-    if (typeof args.workflow === "string" && args.workflow.trim().length > 0) {
-        return `workflow=${truncate(args.workflow, 48)}`;
-    }
-    return undefined;
-}
-function secondaryPreview(args) {
-    if (typeof args.url === "string" && args.url.trim().length > 0) {
-        return truncate(args.url, 60);
-    }
-    const urls = array(args.urls);
-    if (urls !== undefined) {
-        return truncate(urls, 60);
-    }
-    if (typeof args.prompt === "string" && args.prompt.trim().length > 0) {
-        return truncate(args.prompt, 60);
-    }
-    for (const key of [
-        "command",
-        "path",
-        "file_path",
-        "pattern",
-        "query",
-        "url",
-        "task",
-        "describe",
-        "search",
-    ]) {
-        const value = args[key];
-        if (typeof value === "string" && value !== "") {
-            return truncate(value, 60);
-        }
-    }
-    return undefined;
-}
-/** Ordered tool-specific previews, then the first printable unknown argument. */
-export function extractToolArgsPreview(args) {
-    const selected = primaryPreview(args) ?? secondaryPreview(args);
-    if (selected !== undefined) {
-        return selected;
-    }
-    for (const [key, value] of Object.entries(args)) {
-        const preview = array(value);
-        if (preview !== undefined) {
-            return `${key}=${truncate(preview, 50)}`;
-        }
-        if (typeof value === "string" && value.length > 0) {
-            return `${key}=${truncate(value, 50)}`;
-        }
-    }
-    return "";
-}
-function partText(part) {
-    if (!isRecord(part)) {
-        return "";
-    }
-    if (part.type === "tool_result") {
-        return extractTextFromContent(part.content);
-    }
-    return typeof part.text === "string" ? part.text : "";
-}
-/** External content is accepted only as strings or known text/content fields. */
-export function extractTextFromContent(content) {
-    if (typeof content === "string") {
-        return content;
-    }
-    return isUnknownArray(content)
-        ? content
-            .map(partText)
-            .filter((text) => text !== "")
-            .join("\n")
-        : "";
-}

package/dist/shared/execution-cwd.js

@@ -1,22 +0,0 @@
-import { hasExecutionCwdOwner } from "../runs/shared/child-execution-cwd.js";
-function validateDirectoryReply(result) {
-    if (result?.error !== undefined && result.error !== "") {
-        throw new Error(result.error);
-    }
-    if (result && (result.cwd === undefined || result.cwd === "")) {
-        throw new Error("Working-directory owner did not return an execution directory.");
-    }
-}
-/** 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);
-    validateDirectoryReply(request.result);
-    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

@@ -1,22 +0,0 @@
-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

@@ -1,47 +0,0 @@
-import * as fs from "node:fs";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { requestChildExecutionCwd } from "../runs/shared/child-execution-cwd.js";
-import { errorMessage } from "./unknown.js";
-export function resolveSubagentContext(value) {
-    return value === "fork" ? "fork" : "fresh";
-}
-export function createForkContextResolver(sessionManager) {
-    const parentSessionFile = sessionManager.getSessionFile();
-    if (parentSessionFile === undefined || parentSessionFile === "") {
-        throw new Error("Forked subagent context requires a persisted parent session.");
-    }
-    const leafId = sessionManager.getLeafId();
-    if (leafId === null || 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 !== undefined && 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 === undefined || 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) {
-                throw new Error(`Failed to create forked subagent session: ${errorMessage(error)}`, {
-                    cause: error,
-                });
-            }
-        },
-    };
-}

package/dist/shared/formatters.js

@@ -1,111 +0,0 @@
-/**
- * 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) {
-    if (n < 1000) {
-        return String(n);
-    }
-    return n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
-}
-export function formatModelThinking(model, thinking) {
-    const parsed = model !== undefined && model !== "" ? splitKnownThinkingSuffix(model) : undefined;
-    const displayModel = parsed?.baseModel ?? model;
-    const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
-    const displayThinking = parsed?.thinkingSuffix !== undefined && parsed.thinkingSuffix !== ""
-        ? parsed.thinkingSuffix.slice(1)
-        : explicitThinking;
-    return [
-        displayModel,
-        displayThinking !== undefined && displayThinking !== ""
-            ? `thinking ${displayThinking}`
-            : undefined,
-    ]
-        .filter(Boolean)
-        .join(" · ");
-}
-function hasUsageValue(value) {
-    return value !== 0 && !Number.isNaN(value);
-}
-/**
- * Format usage statistics into a compact string
- */
-export function formatUsage(u, model) {
-    const parts = [];
-    if (hasUsageValue(u.turns)) {
-        parts.push(`${u.turns} turn${u.turns > 1 ? "s" : ""}`);
-    }
-    if (hasUsageValue(u.input)) {
-        parts.push(`in:${formatTokens(u.input)}`);
-    }
-    if (hasUsageValue(u.output)) {
-        parts.push(`out:${formatTokens(u.output)}`);
-    }
-    if (hasUsageValue(u.cacheRead)) {
-        parts.push(`R${formatTokens(u.cacheRead)}`);
-    }
-    if (hasUsageValue(u.cacheWrite)) {
-        parts.push(`W${formatTokens(u.cacheWrite)}`);
-    }
-    if (hasUsageValue(u.cost)) {
-        parts.push(`$${u.cost.toFixed(4)}`);
-    }
-    if (model !== undefined && 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": {
-            let target = "";
-            if (typeof args.path === "string") {
-                target = args.path;
-            }
-            else if (typeof args.file_path === "string") {
-                target = 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 !== undefined && home !== "" && p.startsWith(home)) {
-        return `~${p.slice(home.length)}`;
-    }
-    return p;
-}

package/dist/shared/journal-reader.js

@@ -1,6 +0,0 @@
-// Stable public journal entry point; each module owns one storage responsibility.
-export { JsonProjection } from "./json-projection.js";
-export { JournalFrames, scanJournal, readJsonProjection, } from "./journal-frames.js";
-export { ownerProjection, nativeProjection } from "./journal-projections.js";
-export { NativeJournal, journalStamp, } from "./native-journal.js";
-export { readOutputPage } from "./output-page.js";

package/dist/shared/lazy-tools.js

@@ -1,43 +0,0 @@
-import { getCurrentSystemMessage } from "@earendil-works/pi-ai";
-const declarations = new WeakMap();
-/** Only our unnamespaced tools are owned here; foreign public IDs pass through untouched. */
-export function activateTools(pi, names) {
-    const available = pi.getAllTools();
-    const active = pi.getActiveTools();
-    const added = names.filter((name) => !active.includes(name) &&
-        available.some((tool) => tool.name === name &&
-            !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== "")));
-    if (added.length > 0) {
-        pi.setActiveTools([...active, ...new Set(added)]);
-    }
-}
-/** Official 1.0 SDK creation omits initial resume restoration; tree/reload are native. */
-export function restoreLazyTools(pi, ctx, loader, names) {
-    const available = pi.getAllTools();
-    // A tool-only allowlist must remain usable without its discovery entry.
-    if (!available.some((tool) => tool.name === loader &&
-        !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== ""))) {
-        activateTools(pi, names);
-        return;
-    }
-    const manager = ctx.sessionManager, leaf = manager.getLeafId(), count = manager.getEntryCount?.();
-    let cached = declarations.get(manager);
-    if (count === undefined || !cached || cached.leaf !== leaf || cached.count !== count) {
-        cached = {
-            leaf,
-            count,
-            current: getCurrentSystemMessage(manager.buildSessionProjection().messages),
-        };
-        declarations.set(manager, cached);
-    }
-    const declared = cached.current;
-    if (!declared) {
-        return;
-    }
-    const selected = declared.toolsAdded ?? [];
-    const restored = names.filter((name) => selected.some((tool) => tool.name === name &&
-        !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== "")) &&
-        available.some((tool) => tool.name === name &&
-            !("namespace" in tool && typeof tool.namespace === "string" && tool.namespace !== "")));
-    activateTools(pi, restored);
-}