lazycodex-ai 5.0.0-beta.2 → 5.0.0-beta.21

package/dist/cli/install-codex/install-codex-test-fixtures.d.ts

@@ -15,7 +15,7 @@ export declare const EXPECTED_OMO_COMPONENT_BINS: readonly [{
     readonly name: "omo-rules";
     readonly target: string;
 }, {
-    readonly name: "omo-start-work-continuation";
+    readonly name: "omo-ulw-execute-continuation";
     readonly target: string;
 }, {
     readonly name: "omo-telemetry";

package/dist/cli/run/on-complete-hook.d.ts

@@ -3,6 +3,8 @@ import { log } from "../../shared/logger";
 type OnCompleteHookDeps = {
     spawnWithWindowsHide: typeof spawnWithWindowsHide;
     log: typeof log;
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
 };
 export declare function executeOnCompleteHook(options: {
     command: string;

package/dist/cli/runtime-commands.d.ts

@@ -1,2 +1,2 @@
-import type { Command } from "commander";
+import { type Command } from "commander";
 export declare function configureRuntimeCommands(program: Command): void;

package/dist/cli/worktree-sweep/classify.d.ts

@@ -0,0 +1,16 @@
+import type { ClassificationInput, WorktreeClassification, WorktreeRecord } from "./types";
+/**
+ * Externally-owned worktree roots. These are managed by other applications, so
+ * sweeping them would delete state we do not own.
+ */
+export declare const DEFAULT_EXCLUDE_PREFIXES: readonly string[];
+export declare function expandHome(value: string, home: string): string;
+export declare function isExcludedPath(worktreePath: string, prefixes: readonly string[], home: string): boolean;
+/** Branch name when attached, otherwise the detached HEAD sha. */
+export declare function worktreeRef(record: WorktreeRecord): string;
+/**
+ * Single source of truth for sweep decisions. Mirrors the validated `git-wt-cl`
+ * prototype: protection wins over eligibility, and eligibility requires both a
+ * merged (or aged-out) ref and a clean tree.
+ */
+export declare function classifyWorktree(input: ClassificationInput): WorktreeClassification;

package/dist/cli/worktree-sweep/format.d.ts

@@ -0,0 +1,8 @@
+import type { WorktreeClassification, WorktreeSweepResult } from "./types";
+/**
+ * One machine-parseable line per worktree:
+ *   `SWEEP <path> <ref>` / `KEEP(<reason>) <path> <ref>` / `PRUNE <path> <ref>`
+ */
+export declare function formatClassification(classification: WorktreeClassification): string;
+export declare function formatSummary(result: WorktreeSweepResult): string;
+export declare function formatResult(result: WorktreeSweepResult): string[];

package/dist/cli/worktree-sweep/git.d.ts

@@ -0,0 +1,19 @@
+export interface GitResult {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export declare function runGit(cwd: string, args: readonly string[]): Promise<GitResult>;
+export declare function listWorktreesPorcelain(repo: string): Promise<string>;
+/**
+ * Default branch detection: `origin/HEAD` symbolic ref first, then a local
+ * `main`, then `master`. Mirrors the prototype's fallback chain.
+ */
+export declare function detectDefaultBranch(repo: string): Promise<string | undefined>;
+/** `git merge-base --is-ancestor <ref> <default>` — the merged oracle. */
+export declare function isMerged(repo: string, ref: string, defaultBranch: string): Promise<boolean>;
+export declare function isDirty(worktreePath: string): Promise<boolean>;
+/** Never uses `--force`: git itself refuses dirty and locked worktrees. */
+export declare function removeWorktree(repo: string, worktreePath: string): Promise<GitResult>;
+export declare function pruneWorktrees(repo: string): Promise<GitResult>;
+export declare function resolveRepoRoot(cwd: string): Promise<string | undefined>;

package/dist/cli/worktree-sweep/index.d.ts

@@ -0,0 +1,7 @@
+export { classifyWorktree, DEFAULT_EXCLUDE_PREFIXES, isExcludedPath } from "./classify";
+export { formatClassification, formatResult, formatSummary } from "./format";
+export { parseOlderThanDays } from "./options";
+export { parseWorktreeList, linkedWorktrees } from "./parse-worktree-list";
+export { sweepWorktrees } from "./sweep";
+export { worktreeSweep } from "./worktree-sweep";
+export type { ClassificationInput, WorktreeClassification, WorktreeDecision, WorktreeKeepReason, WorktreeRecord, WorktreeSweepOptions, WorktreeSweepRepoReport, WorktreeSweepResult, } from "./types";

package/dist/cli/worktree-sweep/options.d.ts

@@ -0,0 +1,2 @@
+/** Parses the `--older-than <days>` value: a non-negative integer, else throws. */
+export declare function parseOlderThanDays(value: string): number;

package/dist/cli/worktree-sweep/parse-worktree-list.d.ts

@@ -0,0 +1,8 @@
+import type { WorktreeRecord } from "./types";
+/**
+ * Parses `git worktree list --porcelain` output. Records are separated by blank
+ * lines; the first record is always the main worktree.
+ */
+export declare function parseWorktreeList(porcelain: string): WorktreeRecord[];
+/** Drops the main worktree (first record), which is never a sweep candidate. */
+export declare function linkedWorktrees(records: readonly WorktreeRecord[]): WorktreeRecord[];

package/dist/cli/worktree-sweep/sweep.d.ts

@@ -0,0 +1,2 @@
+import type { WorktreeSweepOptions, WorktreeSweepResult } from "./types";
+export declare function sweepWorktrees(options?: WorktreeSweepOptions): Promise<WorktreeSweepResult>;

package/dist/cli/worktree-sweep/types.d.ts

@@ -0,0 +1,65 @@
+export interface WorktreeRecord {
+    /** Absolute worktree path as reported by `git worktree list --porcelain`. */
+    readonly path: string;
+    /** Commit SHA of the worktree HEAD, when reported. */
+    readonly head?: string;
+    /** Short branch name (`refs/heads/` stripped), when the worktree is attached. */
+    readonly branch?: string;
+    readonly detached: boolean;
+    readonly locked: boolean;
+    /** Lock reason string recorded by `git worktree lock --reason`, when present. */
+    readonly lockReason?: string;
+    readonly prunable: boolean;
+}
+export type WorktreeDecision = "SWEEP" | "KEEP" | "PRUNE";
+export type WorktreeKeepReason = "locked" | "external" | "unmerged" | "dirty";
+export interface WorktreeClassification {
+    readonly path: string;
+    /** Branch name when attached, otherwise the HEAD sha; empty when neither is known. */
+    readonly ref: string;
+    readonly decision: WorktreeDecision;
+    readonly reason?: WorktreeKeepReason;
+}
+export interface ClassificationInput {
+    readonly record: WorktreeRecord;
+    /** False when the worktree path no longer exists on disk. */
+    readonly pathExists: boolean;
+    readonly merged: boolean;
+    /** True when `--older-than` is satisfied; always false when `--older-than=0`. */
+    readonly agedOut: boolean;
+    readonly dirty: boolean;
+    /** True when the path lives under one of the configured protected prefixes. */
+    readonly external: boolean;
+}
+export interface WorktreeSweepRepoReport {
+    readonly repo: string;
+    readonly defaultBranch: string;
+    readonly classifications: readonly WorktreeClassification[];
+    /** Paths actually removed; always empty in dry-run mode. */
+    readonly removed: readonly string[];
+    /** Paths that `git worktree remove` refused, with the git error text. */
+    readonly failed: readonly {
+        readonly path: string;
+        readonly error: string;
+    }[];
+}
+export interface WorktreeSweepResult {
+    readonly apply: boolean;
+    readonly olderThanDays: number;
+    readonly repos: readonly WorktreeSweepRepoReport[];
+    readonly sweepCount: number;
+    readonly keepCount: number;
+    readonly pruneCount: number;
+}
+export interface WorktreeSweepOptions {
+    /** Dry-run is the default; only an explicit `true` removes anything. */
+    readonly apply?: boolean;
+    /** 0 means merged-only: unmerged worktrees are never swept. */
+    readonly olderThanDays?: number;
+    /** Repositories to sweep; defaults to the current working directory's repo. */
+    readonly repos?: readonly string[];
+    readonly json?: boolean;
+    /** Overrides the built-in externally-owned path prefixes. */
+    readonly excludePrefixes?: readonly string[];
+    readonly cwd?: string;
+}

package/dist/cli/worktree-sweep/worktree-sweep.d.ts

@@ -0,0 +1,2 @@
+import type { WorktreeSweepOptions } from "./types";
+export declare function worktreeSweep(options?: WorktreeSweepOptions): Promise<number>;