peaks-loop 4.1.2 → 4.1.4

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

@@ -1,64 +1,40 @@
+/**
+ * `peaks skill sediment <verb>` — Sediment pool CLI primitives.
+ *
+ * Slices 2026-07-04-cli-15a (Task 15a) and 2026-07-04-cli-15b (Task 15b)
+ * of the 18-verb plan. This file implements 8 of 18 verbs:
+ *
+ *   Task 15a:
+ *     add-segment   — scaffold ~/.peaks/skills/segments/<name>/SKILL.md
+ *     add-bee       — write ~/.peaks/skills/bees/<name>/manifest.json
+ *     list          — read index.json via readPool
+ *     rebuild-index — rewrite index.json from filesystem state
+ *
+ *   Task 15b:
+ *     refine-bee    — append a NL-described patch to an existing bee manifest
+ *     clone-bee     — duplicate an existing bee to a new name, status reset
+ *     promote       — flip candidate → stable when PromotionGate passes
+ *     retire        — flip → retired, optionally record a reason
+ *
+ * Other verbs (dispose / releases / release-show / release-diff / export /
+ * import / gc-blobs / search / recent / show) return
+ * `{ ok: false, error: "UNKNOWN_VERB: …" }` until Tasks 15c / 15d fill them.
+ *
+ * The CLI boundary is runSediment(argv, { home }): it returns a
+ * `{ ok, error?, data? }` envelope so program.ts can render the result
+ * as JSON via peaks-cli's existing printResult primitive.
+ *
+ * The verb bodies live beside this file — `sediment-pool-commands.ts` (the
+ * pool verbs), `sediment-release-commands.ts` (the retained-release verbs)
+ * and `sediment-query-commands.ts` (the read-only verbs) — with the argv
+ * parser in `sediment-argv-flags.ts`. This module owns the dispatch table,
+ * `parseFlags`' re-export and the commander registration.
+ */
 import type { Command } from 'commander';
 import { type ProgramIO } from '../cli-helpers.js';
-export interface CliResult {
-    ok: boolean;
-    error?: string;
-    data?: unknown;
-}
-/** Typed accessor over the flag map produced by `parseFlags`.
- *
- * `parseFlags` internally stores every flag with at least one value as a
- * `string[]`. A flag with no following non-flag token (e.g. `--apply`,
- * `--dry-run`) is recorded as `true`. This helper exposes three typed
- * accessors so call-sites don't have to re-narrow `unknown` or
- * `string | boolean | string[]` on every read:
- *
- *   - `flags.list(name)`     → `string[]` (always an array; a single
- *                              occurrence is wrapped to a 1-element
- *                              array at parse time)
- *   - `flags.bool(name)`     → `boolean` (presence-of flag; missing
- *                              flag is `false`)
- *   - `flags.maybeString(name)` → `string | undefined` (first value,
- *                              or `undefined` if the flag was given
- *                              as a bare boolean with no value)
- *
- * The dispatch layer (runSediment) was previously peppered with
- * `typeof flags.x === "string"` / `Array.isArray(flags.x)` narrowing.
- * With this helper the call-sites collapse to one-line reads and the
- * raw flag map stops leaking across the runSediment boundary.
- */
-export declare class ParsedFlags {
-    private readonly raw;
-    constructor(raw: Record<string, string[] | true>);
-    /** Always returns an array. Missing flag → []. Single-occurrence
-     *  flag → a 1-element array (parseFlags normalizes this). */
-    list(name: string): string[];
-    /** Presence-of a bare boolean flag. Missing → false. */
-    bool(name: string): boolean;
-    /** First value of a flag, or `undefined` if the flag is absent or
-     *  was given as a bare boolean. */
-    maybeString(name: string): string | undefined;
-}
-/** Parse an argv tail into positional args + flag map.
- *
- * Supports:
- *   --flag value    → flags[flag] = [value, ...] (advance i by 1)
- *   --flag          → flags[flag] = true        (when next token starts with `--` or is undefined)
- *   --flag v1 --flag v2   → repeated `--flag` values are accumulated
- *
- * Internally stores all values as `string[]` (or `true` for a bare
- * boolean flag). Use the `ParsedFlags` helper to read typed accessors.
- *
- * Repeatable flag handling (Task 15b): when the same `--key` appears
- * consecutively (e.g. `--segment a --segment b --segment c`), values
- * are accumulated into a single `string[]`. A single occurrence is
- * normalized to a 1-element array so callers can use `.list(name)`
- * uniformly without shape-narrowing on the call-site.
- */
-export declare function parseFlags(argv: string[]): {
-    positional: string[];
-    flags: ParsedFlags;
-};
+import type { CliResult } from './sediment-command-shared.js';
+export { ParsedFlags, parseFlags } from './sediment-argv-flags.js';
+export type { CliResult } from './sediment-command-shared.js';
 /** Dispatch a sediment verb argv to the matching implementation.
  *
  * Returns { ok: true, data? } on success and { ok: false, error }