@webpresso/agent-kit 3.2.0 → 3.3.1

package/dist/esm/worktrees/orphan-scan.js

@@ -0,0 +1,211 @@
+/**
+ * Filesystem-level orphan scan for `wp worktree prune --orphans`.
+ *
+ * Complements the existing registry-only `wp worktree prune --all`: that
+ * command only drops stale bookkeeping rows from `registry.json`. This module
+ * instead walks the physical managed-worktree roots
+ * (`~/.webpresso/worktrees`, legacy `~/.agent/worktrees`) directly, because a
+ * large share of stale directories on disk were never registered at all
+ * (crashed sessions, `gh pr merge --delete-branch` deregistering the git
+ * worktree out from under the directory, manual `rm` of only part of a
+ * worktree). Git metadata and the registry can both be perfectly clean while
+ * the `~/.webpresso` tree still accumulates dozens of dead directories.
+ *
+ * Classification (see `catalog blueprint worktree-prune-stale-dirs`):
+ *
+ * - `alive`        — path is listed by `git worktree list` for its resolved
+ *                     primary repo. Never removable.
+ * - `orphan`        — a resolvable, existing primary repo's `git worktree
+ *                     list` output does NOT include this path. Removable only
+ *                     when a `git status --porcelain` probe inside the
+ *                     directory succeeds AND reports no changes.
+ * - `broken`        — a primary repo pointer was resolved, but the target
+ *                     repo itself is missing on disk, or its `git worktree
+ *                     list` probe failed outright (bounded, non-retrying).
+ *                     Never removable — the directory's true state cannot be
+ *                     proven.
+ * - `unrecognized`  — no primary repo pointer could be resolved at all
+ *                     (neither `registry.json` nor the directory's own
+ *                     `.git` file yields one), or the directory's `.git`
+ *                     pointer resolves but `git status --porcelain` cannot
+ *                     even run inside it (not a functioning checkout).
+ *                     Reported for manual review; never removable.
+ */
+import { readdirSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { canonicalizeWorktreePath } from "./identity.js";
+function measureSizeSafely(path, deps) {
+    try {
+        return deps.measureSize(path);
+    }
+    catch {
+        return "unknown";
+    }
+}
+function finalizeRow(candidate, classification, reason, deps) {
+    if (classification !== "orphan") {
+        return {
+            ...candidate,
+            classification,
+            dirty: "unknown",
+            sizeBytes: "unknown",
+            removable: false,
+            reason,
+        };
+    }
+    const dirty = deps.probeDirty(candidate.path);
+    if (dirty === "unknown") {
+        return {
+            ...candidate,
+            classification: "unrecognized",
+            dirty,
+            sizeBytes: "unknown",
+            removable: false,
+            reason: "git status probe failed — not a functioning git checkout",
+        };
+    }
+    // Size is decision-relevant only once a row is a confirmed orphan, so it is
+    // measured here — never for alive/broken/unrecognized rows above.
+    const sizeBytes = measureSizeSafely(candidate.path, deps);
+    return {
+        ...candidate,
+        classification,
+        dirty,
+        sizeBytes,
+        removable: dirty === false,
+        reason: dirty ? "uncommitted/untracked changes present" : reason,
+    };
+}
+/** Classify a single on-disk candidate. Pure aside from the injected deps. */
+export function classifyOrphanCandidate(candidate, deps) {
+    const repoRoot = deps.resolveRepoRoot(candidate);
+    if (!repoRoot) {
+        return finalizeRow(candidate, "unrecognized", "no resolvable primary repo pointer", deps);
+    }
+    if (!deps.repoRootExists(repoRoot)) {
+        return finalizeRow(candidate, "broken", `target repo missing: ${repoRoot}`, deps);
+    }
+    const inventory = deps.buildInventory(repoRoot);
+    if (!inventory.complete) {
+        return finalizeRow(candidate, "broken", "git worktree list unavailable for target repo", deps);
+    }
+    const canonical = canonicalizeWorktreePath(candidate.path);
+    if (inventory.canonicalPaths.has(canonical)) {
+        return finalizeRow(candidate, "alive", "present in git worktree list", deps);
+    }
+    return finalizeRow(candidate, "orphan", "absent from git worktree list", deps);
+}
+/** Namespace-keyed lookup of a known-live `repoRoot`, first-registered-wins. */
+export function buildRegistryRepoRootMap(entries) {
+    const map = new Map();
+    for (const entry of entries) {
+        if (!map.has(entry.repoNamespace))
+            map.set(entry.repoNamespace, entry.repoRoot);
+    }
+    return map;
+}
+const WORKTREES_GITDIR_MARKER = "/.git/worktrees/";
+/**
+ * Fallback primary-repo resolver for candidates the registry never recorded:
+ * a linked worktree's `.git` is a file containing `gitdir: <repoRoot>/.git/
+ * worktrees/<name>`. Returns `undefined` when unreadable or unparseable
+ * (e.g. `.git` is a directory, or the pointer target was already reaped).
+ */
+export function resolveRepoRootFromGitPointer(path, readGitPointer) {
+    const content = readGitPointer(join(path, ".git"));
+    if (!content)
+        return undefined;
+    const match = /^gitdir:\s*(.+)$/mu.exec(content.trim());
+    const gitdir = match?.[1]?.trim();
+    if (!gitdir)
+        return undefined;
+    const markerIndex = gitdir.lastIndexOf(WORKTREES_GITDIR_MARKER);
+    if (markerIndex === -1)
+        return undefined;
+    return gitdir.slice(0, markerIndex);
+}
+const MAX_SCAN_DEPTH = 8;
+const SKIP_DIR_NAMES = new Set([".git", "node_modules"]);
+function repoNamespaceFromPath(root, path) {
+    const segments = relative(root, path).split(sep).filter(Boolean);
+    const reposIndex = segments.indexOf("repos");
+    if (reposIndex === -1)
+        return undefined;
+    return segments[reposIndex + 1];
+}
+function walkForCandidates(root, dir, depth, out) {
+    if (depth > MAX_SCAN_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" });
+    }
+    catch {
+        return;
+    }
+    if (entries.some((entry) => entry.name === ".git")) {
+        const repoNamespace = repoNamespaceFromPath(root, dir);
+        if (repoNamespace)
+            out.push({ path: dir, repoNamespace });
+        return; // never descend into a worktree checkout's own contents
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || SKIP_DIR_NAMES.has(entry.name))
+            continue;
+        walkForCandidates(root, join(dir, entry.name), depth + 1, out);
+    }
+}
+/** Walk every known managed-worktree root and collect worktree-shaped leaf dirs. */
+export function discoverOrphanScanCandidates(roots, options = {}) {
+    const dirExists = options.dirExists ??
+        ((path) => {
+            try {
+                return statSync(path).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    const out = [];
+    for (const root of roots) {
+        if (!dirExists(root))
+            continue;
+        walkForCandidates(root, root, 0, out);
+    }
+    return options.repoNamespaceFilter
+        ? out.filter((candidate) => candidate.repoNamespace === options.repoNamespaceFilter)
+        : out;
+}
+/** Bounded recursive directory size, symlinks excluded, unreadable entries skipped. */
+export function measureDirectorySizeBytes(path) {
+    let total = 0;
+    const stack = [path];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            break;
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true, encoding: "utf8" });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+                continue;
+            }
+            try {
+                total += statSync(full).size;
+            }
+            catch {
+                // unreadable file: skip rather than fail the whole scan
+            }
+        }
+    }
+    return total;
+}

package/dist/esm/worktrees/owner-dirt.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Owner-worktree dirt classification for scaffold abandon + merge-cleanup hints.
+ *
+ * Machine-parse `git status --porcelain=v1 -z` only (NUL records; renames are
+ * destination then origin with no `->`). Do not use line-oriented porcelain for
+ * path classification — special characters and renames mis-parse.
+ *
+ * Parity with `isDirty`: ignored files are not considered (no `--ignored`).
+ */
+export type OwnerDirtKind = "clean" | "scaffold-only" | "other";
+export interface OwnerDirtClassification {
+    readonly kind: OwnerDirtKind;
+    /** Repo-relative paths contributing to dirt (bounded callers may slice). */
+    readonly paths: readonly string[];
+    /** Paths under the draft scaffold prefix, when slug is provided. */
+    readonly scaffoldPaths: readonly string[];
+}
+export interface PorcelainPathRecord {
+    readonly statusCode: string;
+    readonly paths: readonly string[];
+}
+/** Blueprint draft tree for a slug (no leading/trailing slash on slug). */
+export declare function draftScaffoldPrefix(slug: string): string;
+export declare function isUnderDraftScaffold(relativePath: string, slug: string): boolean;
+/**
+ * Parse `git status --porcelain=v1 -z` stdout into path records.
+ * Rename/copy: first path is destination, second (next record) is origin.
+ */
+export declare function parsePorcelainV1Z(output: string): readonly PorcelainPathRecord[];
+/**
+ * Classify dirt relative to an optional draft slug.
+ * Without slug, any non-empty porcelain is `other` (or `clean` if empty).
+ */
+export declare function classifyOwnerDirt(porcelainZ: string, slug?: string): OwnerDirtClassification;
+export declare function formatBoundedPaths(paths: readonly string[], limit?: number): string;
+export declare function formatTargetDirtyRefusal(input: {
+    readonly targetPath: string;
+    readonly porcelainZ: string;
+    readonly slug?: string;
+}): string;

package/dist/esm/worktrees/owner-dirt.js

@@ -0,0 +1,104 @@
+/**
+ * Owner-worktree dirt classification for scaffold abandon + merge-cleanup hints.
+ *
+ * Machine-parse `git status --porcelain=v1 -z` only (NUL records; renames are
+ * destination then origin with no `->`). Do not use line-oriented porcelain for
+ * path classification — special characters and renames mis-parse.
+ *
+ * Parity with `isDirty`: ignored files are not considered (no `--ignored`).
+ */
+/** Blueprint draft tree for a slug (no leading/trailing slash on slug). */
+export function draftScaffoldPrefix(slug) {
+    return `blueprints/draft/${slug}`;
+}
+export function isUnderDraftScaffold(relativePath, slug) {
+    const prefix = draftScaffoldPrefix(slug);
+    return relativePath === prefix || relativePath.startsWith(`${prefix}/`);
+}
+/**
+ * Parse `git status --porcelain=v1 -z` stdout into path records.
+ * Rename/copy: first path is destination, second (next record) is origin.
+ */
+export function parsePorcelainV1Z(output) {
+    const records = output.split("\0").filter((record) => record.length > 0);
+    const parsed = [];
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        if (record.length < 3)
+            continue;
+        const statusCode = record.slice(0, 2);
+        const firstPath = record.slice(3);
+        const paths = [firstPath];
+        if (/[RC]/u.test(statusCode)) {
+            const originalPath = records[index + 1];
+            if (originalPath !== undefined) {
+                paths.push(originalPath);
+                index += 1;
+            }
+        }
+        parsed.push({ statusCode, paths });
+    }
+    return parsed;
+}
+/**
+ * Classify dirt relative to an optional draft slug.
+ * Without slug, any non-empty porcelain is `other` (or `clean` if empty).
+ */
+export function classifyOwnerDirt(porcelainZ, slug) {
+    const records = parsePorcelainV1Z(porcelainZ);
+    if (records.length === 0) {
+        return { kind: "clean", paths: [], scaffoldPaths: [] };
+    }
+    const paths = new Set();
+    const scaffoldPaths = new Set();
+    let allScaffold = slug !== undefined && slug.length > 0;
+    for (const record of records) {
+        for (const relativePath of record.paths) {
+            if (relativePath.length === 0)
+                continue;
+            paths.add(relativePath);
+            if (slug && isUnderDraftScaffold(relativePath, slug)) {
+                scaffoldPaths.add(relativePath);
+            }
+            else {
+                allScaffold = false;
+            }
+        }
+    }
+    const pathList = [...paths].toSorted();
+    const scaffoldList = [...scaffoldPaths].toSorted();
+    if (pathList.length === 0) {
+        return { kind: "clean", paths: [], scaffoldPaths: [] };
+    }
+    if (allScaffold && scaffoldList.length > 0) {
+        return { kind: "scaffold-only", paths: pathList, scaffoldPaths: scaffoldList };
+    }
+    return { kind: "other", paths: pathList, scaffoldPaths: scaffoldList };
+}
+export function formatBoundedPaths(paths, limit = 10) {
+    if (paths.length === 0)
+        return "(none)";
+    const head = paths.slice(0, limit);
+    const more = paths.length - head.length;
+    return more > 0 ? `${head.join("\n")}\n(and ${more} more)` : head.join("\n");
+}
+export function formatTargetDirtyRefusal(input) {
+    const classification = classifyOwnerDirt(input.porcelainZ, input.slug);
+    const pathBlock = formatBoundedPaths(classification.paths);
+    const header = `wp worktree merge-cleanup refused: ${input.targetPath} has uncommitted changes`;
+    if (classification.kind === "scaffold-only" && input.slug) {
+        return [
+            header,
+            "Owner has only uncommitted draft scaffold dirt:",
+            pathBlock,
+            `fix: wp blueprint abandon ${input.slug} --confirm`,
+            "  or: commit the draft and land it with the PR",
+        ].join("\n");
+    }
+    return [
+        header,
+        "Paths:",
+        pathBlock,
+        `fix: commit or stash work in ${input.targetPath}, then re-run merge-cleanup`,
+    ].join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpresso/agent-kit",
-  "version": "3.2.0",
+  "version": "3.3.1",
   "private": false,
   "description": "TypeScript-first agent harness for guarded develop/deploy workflows: wp CLI gates, MCP tools, hooks, memory, worktrees, secrets, audits, and evidence checks.",
   "keywords": [
@@ -142,6 +142,8 @@
     "#compiler/*": "./src/compiler/*.ts",
     "#review/*.js": "./src/review/*.ts",
     "#review/*": "./src/review/*.ts",
+    "#rust/*.js": "./src/rust/*.ts",
+    "#rust/*": "./src/rust/*.ts",
     "#telemetry/*.js": "./src/telemetry/*.ts",
     "#telemetry/*": "./src/telemetry/*.ts",
     "#codex/app-server/client": "./src/codex/app-server/client.ts",
@@ -505,16 +507,16 @@
     "setupWpActionRef": "c2c71a7a4be446fc6858e6b57bf55a11ccfa2d88"
   },
   "optionalDependencies": {
-    "@webpresso/agent-kit-runtime-darwin-arm64": "3.2.0",
-    "@webpresso/agent-kit-runtime-darwin-x64": "3.2.0",
-    "@webpresso/agent-kit-runtime-linux-x64": "3.2.0",
-    "@webpresso/agent-kit-runtime-linux-arm64": "3.2.0",
-    "@webpresso/agent-kit-runtime-windows-x64": "3.2.0",
-    "@webpresso/agent-kit-session-memory-darwin-x64": "3.2.0",
-    "@webpresso/agent-kit-session-memory-darwin-arm64": "3.2.0",
-    "@webpresso/agent-kit-session-memory-linux-x64": "3.2.0",
-    "@webpresso/agent-kit-session-memory-linux-arm64": "3.2.0",
-    "@webpresso/agent-kit-session-memory-win32-x64": "3.2.0",
-    "@webpresso/agent-kit-session-memory-win32-arm64": "3.2.0"
+    "@webpresso/agent-kit-runtime-darwin-arm64": "3.3.1",
+    "@webpresso/agent-kit-runtime-darwin-x64": "3.3.1",
+    "@webpresso/agent-kit-runtime-linux-x64": "3.3.1",
+    "@webpresso/agent-kit-runtime-linux-arm64": "3.3.1",
+    "@webpresso/agent-kit-runtime-windows-x64": "3.3.1",
+    "@webpresso/agent-kit-session-memory-darwin-x64": "3.3.1",
+    "@webpresso/agent-kit-session-memory-darwin-arm64": "3.3.1",
+    "@webpresso/agent-kit-session-memory-linux-x64": "3.3.1",
+    "@webpresso/agent-kit-session-memory-linux-arm64": "3.3.1",
+    "@webpresso/agent-kit-session-memory-win32-x64": "3.3.1",
+    "@webpresso/agent-kit-session-memory-win32-arm64": "3.3.1"
   }
 }