tickmarkr 1.65.0 → 1.67.0

package/dist/tui/save.d.ts

@@ -0,0 +1,38 @@
+import { type FleetEditable } from "../config/config.js";
+export type SaveTarget = "repo" | "global";
+/** Notice surfaced in the save modal whenever a run lock is live. */
+export declare const RELOAD_GUARD_NOTICE = "reload guard: a live run is active; the running daemon will not see these changes until it reloads";
+export type SaveProposal = {
+    target: SaveTarget;
+    targetPath: string;
+    before: string;
+    after: string;
+    diff: string;
+    liveRun: boolean;
+    loadError: string | null;
+};
+export type SaveResult = {
+    kind: "written";
+    path: string;
+} | {
+    kind: "declined";
+} | {
+    kind: "refused";
+    reason: string;
+};
+/** Build the diff-confirm payload for the current staging delta and chosen target. */
+export declare function buildSaveProposal(opts: {
+    repoRoot: string;
+    loaded: FleetEditable;
+    staged: FleetEditable;
+    target: SaveTarget;
+    globalDir?: string;
+}): SaveProposal;
+/** Confirm and execute the write for the chosen target. */
+export declare function confirmSave(opts: {
+    repoRoot: string;
+    loaded: FleetEditable;
+    staged: FleetEditable;
+    target: SaveTarget;
+    globalDir?: string;
+}): SaveResult;

package/dist/tui/save.js

@@ -0,0 +1,96 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, repoOverlayYaml, unifiedYamlDiff, } from "../config/config.js";
+import { isRunLockLive } from "../run/lock.js";
+/** Notice surfaced in the save modal whenever a run lock is live. */
+export const RELOAD_GUARD_NOTICE = "reload guard: a live run is active; the running daemon will not see these changes until it reloads";
+function overlayPath(repoRoot, target, globalDir) {
+    return target === "repo"
+        ? repoOverlayPath(repoRoot)
+        : join(globalDir ?? globalConfigDir(), "config.yaml");
+}
+function currentOverlayText(path) {
+    return existsSync(path) ? readFileSync(path, "utf8") : "";
+}
+function computeAfterBytes(target, loaded, staged, repoRoot, globalDir) {
+    const path = overlayPath(repoRoot, target, globalDir);
+    const existing = readOverlayFile(path);
+    // Reuse the existing fleet serializer and diff renderer rather than inventing a parallel formatter.
+    const merged = fleetRepoOverlayFromDelta(loaded, staged, existing);
+    return repoOverlayYaml(merged);
+}
+function roundTripError(target, repoRoot, after, staged, globalDir) {
+    try {
+        let effective;
+        if (target === "repo") {
+            effective = loadConfigWithMode(repoRoot, { globalDir, repoOverlayText: after });
+        }
+        else {
+            // Validate a candidate global overlay by loading with it in a scratch globalDir.
+            const scratch = mkdtempSync(join(tmpdir(), "tickmarkr-global-rt-"));
+            try {
+                writeFileSync(join(scratch, "config.yaml"), after);
+                effective = loadConfigWithMode(repoRoot, { globalDir: scratch });
+            }
+            finally {
+                try {
+                    rmSync(scratch, { recursive: true, force: true });
+                }
+                catch { /* best-effort cleanup */ }
+            }
+        }
+        const reparsed = fleetEditableFromConfig(effective.cfg);
+        if (!fleetEditableEquals(reparsed, staged)) {
+            return "round-trip mismatch: the written overlay does not re-parse to the staged state";
+        }
+        return null;
+    }
+    catch (e) {
+        return e.message;
+    }
+}
+/** Build the diff-confirm payload for the current staging delta and chosen target. */
+export function buildSaveProposal(opts) {
+    const path = overlayPath(opts.repoRoot, opts.target, opts.globalDir);
+    const before = currentOverlayText(path);
+    const after = computeAfterBytes(opts.target, opts.loaded, opts.staged, opts.repoRoot, opts.globalDir);
+    const diff = unifiedYamlDiff(before, after, path);
+    const loadError = roundTripError(opts.target, opts.repoRoot, after, opts.staged, opts.globalDir);
+    return {
+        target: opts.target,
+        targetPath: path,
+        before,
+        after,
+        diff,
+        liveRun: isRunLockLive(opts.repoRoot),
+        loadError,
+    };
+}
+function atomicWrite(path, bytes) {
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    // The sibling temp keeps rename(2) on one filesystem: readers see old or new bytes, never a partial overlay.
+    const tmp = join(dir, `.tickmarkr-save-${randomUUID()}.tmp`);
+    try {
+        writeFileSync(tmp, bytes);
+        renameSync(tmp, path);
+    }
+    catch (e) {
+        rmSync(tmp, { force: true }); // a failed rename must not leave a partial candidate behind
+        throw e;
+    }
+}
+/** Confirm and execute the write for the chosen target. */
+export function confirmSave(opts) {
+    const proposal = buildSaveProposal(opts);
+    if (proposal.loadError) {
+        return { kind: "refused", reason: proposal.loadError };
+    }
+    if (proposal.before === proposal.after) {
+        return { kind: "declined" };
+    }
+    atomicWrite(proposal.targetPath, proposal.after);
+    return { kind: "written", path: proposal.targetPath };
+}

package/dist/tui/staging.d.ts

@@ -0,0 +1,29 @@
+import { type FleetEditable } from "../config/config.js";
+/** One in-memory edit to the buffered fleet state. */
+export type FleetEdit = (buffer: FleetEditable) => void;
+/**
+ * Staged-changes buffer for the Fleet Studio write path.
+ *
+ * - The loaded state is captured at construction and never mutated.
+ * - Edits apply to an in-memory buffer only.
+ * - `revert()` discards the buffer and restores the loaded state.
+ * - The delta is computed through the existing `fleetEditableEquals` comparison.
+ * - No code path in this module writes to disk.
+ */
+export declare class FleetStaging {
+    private readonly loaded;
+    private buffer;
+    constructor(loaded: FleetEditable);
+    /** Read-only snapshot of the originally loaded state. */
+    get loadedState(): FleetEditable;
+    /** Current buffered (possibly edited) state. */
+    get current(): FleetEditable;
+    /** Apply an edit to the buffer. Never touches disk. */
+    apply(edit: FleetEdit): void;
+    /** Discard all buffered edits and restore the loaded state. */
+    revert(): void;
+    /** True when the buffer differs from the loaded state. */
+    get isDirty(): boolean;
+    /** Number of distinct staged changes vs the loaded state. */
+    get changeCount(): number;
+}

package/dist/tui/staging.js

@@ -0,0 +1,78 @@
+import { fleetEditableEquals } from "../config/config.js";
+/**
+ * Staged-changes buffer for the Fleet Studio write path.
+ *
+ * - The loaded state is captured at construction and never mutated.
+ * - Edits apply to an in-memory buffer only.
+ * - `revert()` discards the buffer and restores the loaded state.
+ * - The delta is computed through the existing `fleetEditableEquals` comparison.
+ * - No code path in this module writes to disk.
+ */
+export class FleetStaging {
+    loaded;
+    buffer;
+    constructor(loaded) {
+        this.loaded = structuredClone(loaded);
+        this.buffer = structuredClone(loaded);
+    }
+    /** Read-only snapshot of the originally loaded state. */
+    get loadedState() {
+        return structuredClone(this.loaded);
+    }
+    /** Current buffered (possibly edited) state. */
+    get current() {
+        return structuredClone(this.buffer);
+    }
+    /** Apply an edit to the buffer. Never touches disk. */
+    apply(edit) {
+        edit(this.buffer);
+    }
+    /** Discard all buffered edits and restore the loaded state. */
+    revert() {
+        this.buffer = structuredClone(this.loaded);
+    }
+    /** True when the buffer differs from the loaded state. */
+    get isDirty() {
+        return !fleetEditableEquals(this.loaded, this.buffer);
+    }
+    /** Number of distinct staged changes vs the loaded state. */
+    get changeCount() {
+        return fleetEditableDeltaCount(this.loaded, this.buffer);
+    }
+}
+/** Count changed leaves using the same equality semantics as `fleetEditableEquals`. */
+function fleetEditableDeltaCount(initial, edited) {
+    let count = 0;
+    if (JSON.stringify(initial.denyAdapters) !== JSON.stringify(edited.denyAdapters)) {
+        count += 1;
+    }
+    if (JSON.stringify(initial.denyModels) !== JSON.stringify(edited.denyModels)) {
+        count += 1;
+    }
+    const mapKeys = new Set([...Object.keys(initial.map), ...Object.keys(edited.map)]);
+    for (const shape of mapKeys) {
+        if (JSON.stringify(initial.map[shape]) !== JSON.stringify(edited.map[shape])) {
+            count += 1;
+        }
+    }
+    const floorKeys = new Set([...Object.keys(initial.floors), ...Object.keys(edited.floors)]);
+    for (const shape of floorKeys) {
+        if (initial.floors[shape] !== edited.floors[shape]) {
+            count += 1;
+        }
+    }
+    const adapterKeys = new Set([...Object.keys(initial.tiers), ...Object.keys(edited.tiers)]);
+    for (const adapter of adapterKeys) {
+        const modelKeys = new Set([
+            ...Object.keys(initial.tiers[adapter] ?? {}),
+            ...Object.keys(edited.tiers[adapter] ?? {}),
+        ]);
+        for (const model of modelKeys) {
+            if (JSON.stringify(initial.tiers[adapter]?.[model]) !==
+                JSON.stringify(edited.tiers[adapter]?.[model])) {
+                count += 1;
+            }
+        }
+    }
+    return count;
+}

package/dist/tui/views/diff-modal.d.ts

@@ -0,0 +1,9 @@
+import { type SaveTarget } from "../save.js";
+export type DiffModalProps = {
+    target: SaveTarget;
+    targetPath: string;
+    diff: string;
+    liveRun: boolean;
+};
+/** Render the save-confirmation modal: header names the target path, body shows the exact overlay diff. */
+export declare function renderDiffModal(props: DiffModalProps): string[];

package/dist/tui/views/diff-modal.js

@@ -0,0 +1,19 @@
+import { bold, dim, fail, legend } from "../../brand.js";
+import { RELOAD_GUARD_NOTICE } from "../save.js";
+/** Render the save-confirmation modal: header names the target path, body shows the exact overlay diff. */
+export function renderDiffModal(props) {
+    const lines = [];
+    lines.push(bold(`Save overlay — ${props.targetPath} (${props.target === "repo" ? "repository" : "global"} target)`));
+    lines.push(legend("t toggle target · y confirm · n/esc cancel"));
+    if (props.liveRun) {
+        lines.push(fail(RELOAD_GUARD_NOTICE));
+    }
+    lines.push(dim("─ diff ─"));
+    if (props.diff) {
+        lines.push(...props.diff.trimEnd().split("\n"));
+    }
+    else {
+        lines.push(dim("(no overlay changes)"));
+    }
+    return lines;
+}

package/dist/tui/views/fleet-view.d.ts

@@ -0,0 +1,91 @@
+import type { View } from "../app.js";
+import type { AuthHealth } from "../../adapters/types.js";
+import type { Tier } from "../../config/config.js";
+import type { TelemetryRow } from "../../run/journal.js";
+import type { FleetStaging } from "../staging.js";
+/** One discovered adapter and its classified models (cfg.tiers via channels()). */
+export type FleetRosterEntry = {
+    adapter: string;
+    models: {
+        model: string;
+        tier: Tier;
+        channel: "sub" | "api";
+    }[];
+};
+/** Provenance notes harvested from overlay `# comment`s (fleet-overlay.ts shapes). */
+export type FleetProvenanceNotes = {
+    denyAdapters?: Record<string, string>;
+    denyModels?: Record<string, string>;
+};
+/** Everything the roster renders — loaded by the caller, never by the render path. */
+export type FleetViewData = {
+    adapters: FleetRosterEntry[];
+    /** Doctor cache contents (doctor.json), keyed by adapter id. */
+    health: Record<string, AuthHealth>;
+    /** Age of the doctor cache in ms; null when no probe data exists. */
+    doctorAgeMs: number | null;
+    denyAdapters: string[];
+    /** routing.deny.models entries in channelKey form ("adapter:model"). */
+    denyModels: string[];
+    notes?: FleetProvenanceNotes;
+    /** Telemetry folded from recent run journals (readAllTelemetry); runId optional. */
+    telemetry: (TelemetryRow & {
+        runId?: string;
+    })[];
+};
+/** Per-channel health digest, folded from journal telemetry rows only. */
+export type ChannelHealth = {
+    key: string;
+    tasks: number;
+    attempts: number;
+    done: number;
+    failed: number;
+    human: number;
+    overruns: number;
+    quotaFailovers: number;
+    /** Sum of OBSERVED gateFails; null when no row carried the field (unobserved, never 0). */
+    gateFails: number | null;
+    medianDurationMs: number | null;
+    lastOutcome: TelemetryRow["outcome"] | null;
+};
+/** Fold journal telemetry rows into a per-channel health digest keyed by channelKey
+ *  ("adapter:model"). The digest derives from journal telemetry (TelemetryRow, the rows the
+ *  daemon appends to each run's telemetry.jsonl) rather than any new state file: this module
+ *  reads nothing and writes nothing — the caller folds rows out of the existing run journals
+ *  (readAllTelemetry) and the fold is a pure function of them, same telemetry in, same digest
+ *  out. */
+export declare function foldChannelHealth(rows: (TelemetryRow & {
+    runId?: string;
+})[]): Map<string, ChannelHealth>;
+/** The studio View plus the roster's own key seam. The T2 shell binds only view-level keys, so
+ *  expand/collapse and selection are driven through key() — the same names the engine decodes. */
+export type FleetView = View & {
+    /** Handle a decoded key name ("up" | "down" | "left" | "right" | "space" | "return"). */
+    key(name: string): void;
+    /** Whether an adapter's model rows are currently shown. */
+    expanded(adapter: string): boolean;
+    /** channelKey of the cursor's channel, or null when the cursor sits on an adapter row. */
+    selectedChannel(): string | null;
+    /** Stage a deny⇄allow toggle for one adapter into the shared buffer. No-op without staging. */
+    toggleDenyAdapter(adapter: string): void;
+    /** Stage a deny⇄allow toggle for one channel ("adapter:model"). No-op without staging. */
+    toggleDenyChannel(channelKey: string): void;
+    /** Stage a tier override for one channel ("adapter:model"). No-op without staging. */
+    stageTierOverride(channelKey: string, tier: Tier): void;
+};
+/** A channel that is denied in the staged buffer while a routing.map pin still points at it —
+ *  the fleet view stages the deny, the routing view stages the pin, and BOTH are read out of the
+ *  one shared staging model, so either view surfaces the same conflict set. */
+export type StagedConflict = {
+    /** channelKey ("adapter:model") that is both denied and pinned in the buffer. */
+    channelKey: string;
+    /** shapes whose pin the deny would dead-end (deny wins over pin in saved config). */
+    shapes: string[];
+};
+/** Detect deny-vs-pin conflicts from the shared staging model. The buffer's CURRENT state holds
+ *  both views' staged state — the fleet view's deny/allow + tier edits and the routing view's
+ *  pin/floor edits — so reading it sees the combination before anything is saved. A conflict is
+ *  a pinned channel denied by its own entry OR by its adapter's deny (the adapter deny reaches
+ *  every channel under it, same rule as denyOf). */
+export declare function stagedConflicts(staging: FleetStaging): StagedConflict[];
+export declare function createFleetView(data?: FleetViewData, staging?: FleetStaging): FleetView;