@boopkit/cli 0.4.0 → 0.6.0

package/dist/commands/loop.d.ts

@@ -15,6 +15,8 @@ export interface LoopOptions {
     skipPerms?: boolean;
     bare?: boolean;
     json?: boolean;
+    merge?: boolean | string;
+    watch?: boolean;
 }
 interface ClaudeRunResult {
     exitCode: number;
@@ -24,6 +26,79 @@ export interface PlanResult {
     featureId: string | null;
     costUsd: number | null;
 }
+export type WorktreeMode = 'work-flow' | 'prefix';
+export interface WorktreeContext {
+    path: string;
+    branch: string;
+    scope: string;
+    mode: WorktreeMode;
+}
+/**
+ * Hard requirement: beads must run in Dolt server mode so concurrent worktrees
+ * share one issue DB over TCP. Reads `.beads/metadata.json` and throws an
+ * actionable error on embedded/missing — call before any `bd` work.
+ */
+export declare function assertDoltServerMode(projectDir: string, deps?: {
+    existsSyncFn?: (p: string) => boolean;
+    readFileFn?: (p: string, enc: string) => string;
+}): void;
+/**
+ * Discover the running shared Dolt server's port from `.beads/dolt-server.port`.
+ * Worktrees never start their own server — they reuse this one over TCP.
+ * Returns null when no port file is present (caller errors clearly). Liveness
+ * (pid still running) is best-effort and never blocks discovery.
+ */
+export declare function discoverDoltServer(projectDir: string, deps?: {
+    existsSyncFn?: (p: string) => boolean;
+    readFileFn?: (p: string, enc: string) => string;
+    isPidAliveFn?: (pid: number) => boolean;
+}): {
+    port: number;
+    pid?: number;
+    alive?: boolean;
+} | null;
+/**
+ * Create (or reuse) the loop's own git worktree at `../boop-<scope>` on branch
+ * `work/<scope>`, then pre-warm `npm install --prefer-offline`. This is what
+ * makes N loops run concurrently without colliding — each gets its own tree and
+ * branch; main is never checked out.
+ *
+ * Collision (Decision #4): if a worktree already exists at the path on the same
+ * branch, reuse it (and skip install if node_modules is present); if the path is
+ * occupied by something else, throw a clear error rather than silently suffixing.
+ */
+export declare function createWorktree(scope: string, mode: WorktreeMode, projectDir: string, deps?: {
+    execSyncFn?: (cmd: string, opts: {
+        encoding: string;
+        cwd?: string;
+        stdio?: unknown;
+    }) => string;
+    existsSyncFn?: (p: string) => boolean;
+    copyFileFn?: (src: string, dest: string) => void;
+    readdirFn?: (p: string) => string[];
+    readFileFn?: (p: string) => string;
+    appendFileFn?: (p: string, data: string) => void;
+}): WorktreeContext;
+/**
+ * Write `.boop-worktree.json` into the worktree root. This is the contract
+ * Slice 2 (`boop loop --merge`) reads — `mode` drives its readiness query.
+ */
+export declare function writeWorktreeMetadata(ctx: WorktreeContext, meta: {
+    workPath?: string;
+    flowPath?: string;
+    boopVersion: string;
+    startTime: string;
+    operator?: string;
+    budget?: string;
+    model?: string;
+}, deps?: {
+    writeFileFn?: (p: string, data: string) => void;
+}): Record<string, unknown>;
+interface ReadyIssue {
+    id: string;
+    issue_type: string;
+    parent?: string;
+}
 export declare function buildPlanningPrompt(workContent: string, flowContent: string, prefix?: string): string;
 export type RunClaudeFn = (prompt: string, opts: {
     budget: string;
@@ -32,6 +107,7 @@ export type RunClaudeFn = (prompt: string, opts: {
     sessionId: string;
     resume?: boolean;
     bare?: boolean;
+    cwd?: string;
 }, logFile: string, readableLogFile?: string) => Promise<ClaudeRunResult>;
 export declare function planWork(opts: {
     workPath: string;
@@ -55,9 +131,75 @@ export declare function findFallbackFeature(features: Array<{
 export declare function extractFeatureId(text: string): string | null;
 export declare function isUsageLimitText(text: string): boolean;
 export declare function isStandaloneUsageLimitMessage(text: string): boolean;
+/**
+ * Resolve the model for a loop run. Precedence: an explicit `--model` flag, then
+ * the `ANTHROPIC_MODEL` environment variable, then the built-in default. The env
+ * fallback is what lets a nested `boop loop` (spawned by a Claude session that
+ * the parent loop launched with ANTHROPIC_MODEL set) inherit the same model
+ * instead of silently dropping to the default. Keep the default (claude-opus-4-8)
+ * in sync with the `--model` help text in cli.ts.
+ */
+export declare function resolveModel(optionModel: string | undefined, env?: NodeJS.ProcessEnv): string;
+/**
+ * Whether the loop should resume an issue that a session left open. A `blocked`
+ * issue was deliberately halted by the prior session because it judged it could
+ * not safely proceed — resuming just spends budget re-halting and risks the
+ * resume prompt being read as authorization to work past the block. Stop and
+ * surface it for the operator instead. Any other open status is genuinely
+ * unfinished work and is fine to resume.
+ */
+export declare function shouldResumeUnclosedIssue(status: string | undefined): boolean;
 export declare function isIssueInScope(issue: {
     id: string;
     parent?: string;
 }, prefix: string, getParentById: (id: string) => string | null): boolean;
+/**
+ * A workflow-owned feature root is a feature-type issue that owns child tasks
+ * (the workflow steps: understand → plan → … → closeout). Once those children
+ * close, `bd ready` surfaces the feature root itself — but it is a *container*,
+ * not directly claimable work. Claiming it lets a worker session absorb
+ * punch-list fixes or whole workflow steps (the boop-qna / wishfleet-O7 bug).
+ *
+ * `hasChildren` is only consulted for feature-type issues, so non-features never
+ * pay the cost of the children lookup.
+ */
+export declare function isClaimableReadyIssue(issue: {
+    id: string;
+    issue_type: string;
+}, hasChildren: (id: string) => boolean): boolean;
+/**
+ * Decide whether the loop should close a feature root itself, as a safety net,
+ * when its workflow chain has completed. The intended owner of this close is the
+ * closeout child task (see boop-feature-dev-workflow SKILL step 6), but if that
+ * task never closed the root — or no closeout task exists — the feature would be
+ * orphaned open forever once filtered from claimable work. Only close when the
+ * feature is still open and every child is closed.
+ */
+export declare function shouldCloseFeatureRoot(feature: {
+    status: string;
+    issue_type: string;
+} | null, children: {
+    status: string;
+}[]): boolean;
+export declare function getMatchingReadyIssues(prefix: string, includeFeatures: boolean, deps?: {
+    execSyncFn?: (cmd: string, opts: {
+        encoding: string;
+    }) => string;
+}): ReadyIssue[];
+/**
+ * Default per-issue budget cap in USD. The planning phase and each task each get
+ * this cap. Single source of truth — imported by cli.ts for its --budget help
+ * text so the documented default and the runtime fallback can't drift.
+ */
+export declare const DEFAULT_BUDGET_USD = "25.00";
+/**
+ * Sent when resuming a session that ended without closing its issue. The opener
+ * must NOT read as operator authorization (the old "Approved. Continue..." text
+ * could be taken as permission to work past a block): an agent that marked the
+ * issue `blocked` made a deliberate safety call, and the block stands. The loop
+ * also skips resuming a `blocked` issue entirely (see shouldResumeUnclosedIssue)
+ * — this clause is the belt-and-suspenders for a block raised mid-resume.
+ */
+export declare const RESUME_PROMPT = "The previous session ended without closing this issue. Reload the state and continue.\n\nIMPORTANT: If the previous session marked this issue blocked with a diagnostic, the block stands. Do not re-open it or work around it. Read the issue's notes and the previous session's commits, confirm the block is still appropriate, and stop without taking further action.\n\nOtherwise, complete the workflow:\n- Finish any remaining implementation\n- Run tests to verify\n- Commit changes referencing the issue ID\n- Close the issue with bd close\n- Push with: git pull --rebase && git push\n\nDo not pause for review of completed work. Complete everything now.";
 export declare function runLoop(options: LoopOptions): Promise<void>;
 export {};