astroshot 0.2.1 → 0.2.2

package/node_modules/@archastro/astroshot/README.md

@@ -13,6 +13,10 @@ npx astroshot demo
 # Check Node, watched folders, app install/run state, Chromium, and macOS
 # Screen Recording. Each failure prints the exact fix command. Read-only.
 npx astroshot doctor
+
+# Review the stream in your terminal (Ghostty, kitty, or WezTerm draw the
+# pictures; ffmpeg plays movies). Same review.json as the macOS app.
+npx astroshot review
 ```
 
 `demo` accepts `--feature <name>`, `--root <dir>`, and `--json`. `doctor`

package/node_modules/@archastro/astroshot/bin/astroshot.mjs

@@ -8,12 +8,14 @@ import path from "node:path";
 import { writeFixtureTemplate } from "./templates.mjs";
 import { demoHelp, runDemo } from "./demo.mjs";
 import { doctorHelp, runDoctor } from "./doctor.mjs";
+import { readWatchConfiguration } from "./mac-preferences.mjs";
 
 function help() {
   console.log(`astroshot — one CLI for React, Ink, PTY stills, and movies
 
 Usage:
-  astroshot demo [--feature <name>] [--root <dir>]
+  astroshot review [<dir>...] [--root <dir>] [--no-graphics]
+  astroshot demo [--feature <name>] [--root <dir>] [--dry-run] [--clean]
   astroshot doctor [--root <dir>] [--json]
   astroshot init react [fixture.tsx] [--force]
   astroshot init ink [fixture.tsx] [--force]
@@ -28,6 +30,7 @@ Usage:
   astroshot install-browser [--with-deps]
 
 Start here:
+  review             Review the .astroshot/ stream in your terminal (Kitty graphics)
   demo               Write a complete .astroshot/ example set (no prerequisites)
   doctor             Check Node, watched folders, app, Chromium, permissions
 
@@ -104,6 +107,11 @@ Options:
 }
 
 function engineBin(mode) {
+  if (mode === "review") {
+    const entry = fileURLToPath(import.meta.resolve("@archastro/astroshot-review"));
+    const packageRoot = path.dirname(path.dirname(entry));
+    return path.join(packageRoot, "bin", "astroshot-review.mjs");
+  }
   if (mode === "movie") {
     const entry = fileURLToPath(import.meta.resolve("@archastro/movie-harness"));
     // package exports "." → dist/index.js → package root is two levels up from dist
@@ -189,6 +197,49 @@ function runInit(arguments_) {
   console.log(`Created ${result.label} fixture: ${result.absolutePath}`);
 }
 
+/**
+ * `astroshot review`: the terminal tray. Without explicit roots it watches
+ * the same folders as the Astroshots app so both surfaces show one stream.
+ */
+function runReview(arguments_) {
+  // `astroshot review help` mirrors the other modes; anything else is
+  // forwarded verbatim so a folder literally named "help" still works.
+  const wantsHelp =
+    arguments_[0] === "help" ||
+    arguments_.includes("-h") ||
+    arguments_.includes("--help");
+  const forwarded = wantsHelp ? ["--help"] : [...arguments_];
+  const hasRoots =
+    forwarded.includes("--root") ||
+    forwarded.some((value) => !value.startsWith("-"));
+  if (!hasRoots && !wantsHelp) {
+    const configuration = readWatchConfiguration();
+    if (configuration.available && configuration.roots.length > 0) {
+      for (const root of configuration.roots) forwarded.push("--root", root);
+      forwarded.push("--roots-source", "app");
+    }
+  }
+  let engine;
+  try {
+    engine = engineBin("review");
+  } catch (error) {
+    console.error(
+      `astroshot could not find the review tray engine (@archastro/astroshot-review): ${error instanceof Error ? error.message : error}`,
+    );
+    console.error("Reinstall @archastro/astroshot (or the unscoped astroshot package) and retry.");
+    process.exit(1);
+  }
+  const result = spawnSync(process.execPath, [engine, ...forwarded], {
+    stdio: "inherit",
+  });
+  if (result.error) {
+    console.error(`astroshot could not start the review tray: ${result.error.message}`);
+    process.exit(1);
+  }
+  if (result.signal) process.kill(process.pid, result.signal);
+  process.exit(result.status ?? 1);
+}
+
 const [command, ...arguments_] = process.argv.slice(2);
 
 if (command === "-v" || command === "--version") {
@@ -254,6 +305,10 @@ if (command === "react" || command === "ink" || command === "tui" || command ===
   runEngine(canonicalMode, arguments_);
 }
 
+if (command === "review" || command === "tray") {
+  runReview(arguments_);
+}
+
 if (command === "movie") {
   // Always forward to movie-harness (including --help / which-source).
   const result = spawnSync(

package/node_modules/@archastro/astroshot/bin/demo.mjs

@@ -30,6 +30,8 @@ Options:
   --feature <name>   Feature directory under .astroshot/ (default: ${DEFAULT_DEMO_FEATURE})
   --root <dir>       Worktree root (default: git root, else cwd)
   --json             Print the written paths as JSON
+  --dry-run          Print planned paths without writing
+  --clean            Accepted; does not delete yet
   -h, --help         Show this help
 
 Writes two stills, one movie poster + video pair, and manifest.json using
@@ -112,14 +114,24 @@ export function loadDemoFixtures(fixturesDirectory = FIXTURES_DIR) {
   return index;
 }
 
+function publicDemoResult(plan) {
+  return {
+    root: plan.root,
+    feature: plan.feature,
+    featureDirectory: plan.featureDirectory,
+    manifestPath: plan.manifestPath,
+    runId: plan.runId,
+    shots: plan.shots,
+    files: plan.files,
+  };
+}
+
 /**
- * Write the demo set and return the paths, without printing anything.
- *
- * Each invocation is its own run: a new `run_id` with a fresh shot list, while
- * earlier numbered frames stay on disk as prior-run evidence. That matches the
- * documented lifecycle used by astroshot-capture and the movie harness.
+ * Read-only plan of the next demo write: same root/feature resolve, kebab-case
+ * check, fixtures, next sequence, and file names (including manifest.json).
+ * Does not mkdir or write.
  */
-export function writeDemo({
+export function planDemo({
   root,
   feature = DEFAULT_DEMO_FEATURE,
   fixturesDirectory = FIXTURES_DIR,
@@ -130,7 +142,6 @@ export function writeDemo({
   const featureDirectory = path.join(resolvedRoot, ".astroshot", feature);
   const index = loadDemoFixtures(fixturesDirectory);
 
-  fs.mkdirSync(featureDirectory, { recursive: true });
   const startSequence = nextSequence(featureDirectory);
   const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
   // The first sequence of this run keeps the id unique when two runs land in
@@ -140,11 +151,16 @@ export function writeDemo({
 
   const shots = [];
   const files = [];
+  const copies = [];
   index.shots.forEach((fixture, offset) => {
     const sequence = String(startSequence + offset).padStart(4, "0");
     const posterName = `${sequence}-${fixture.slug}.png`;
-    copyAtomic(path.join(fixturesDirectory, fixture.asset), path.join(featureDirectory, posterName));
-    files.push(path.join(featureDirectory, posterName));
+    const posterPath = path.join(featureDirectory, posterName);
+    copies.push({
+      source: path.join(fixturesDirectory, fixture.asset),
+      destination: posterPath,
+    });
+    files.push(posterPath);
 
     const shot = {
       id: sequence,
@@ -159,8 +175,12 @@ export function writeDemo({
     if (fixture.video) {
       const videoExtension = path.extname(fixture.video) || ".webm";
       const videoName = `${sequence}-${fixture.slug}${videoExtension}`;
-      copyAtomic(path.join(fixturesDirectory, fixture.video), path.join(featureDirectory, videoName));
-      files.push(path.join(featureDirectory, videoName));
+      const videoPath = path.join(featureDirectory, videoName);
+      copies.push({
+        source: path.join(fixturesDirectory, fixture.video),
+        destination: videoPath,
+      });
+      files.push(videoPath);
       shot.kind = "movie";
       shot.video = videoName;
       shot.duration_ms = fixture.duration_ms;
@@ -181,7 +201,6 @@ export function writeDemo({
       "Synthetic proof set written by `astroshot demo` — stills plus one journey movie.",
     shots,
   };
-  writeAtomic(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
   files.push(manifestPath);
 
   return {
@@ -189,12 +208,31 @@ export function writeDemo({
     feature,
     featureDirectory,
     manifestPath,
+    manifest,
     runId,
     shots,
     files,
+    copies,
   };
 }
 
+/**
+ * Write the demo set and return the paths, without printing anything.
+ *
+ * Each invocation is its own run: a new `run_id` with a fresh shot list, while
+ * earlier numbered frames stay on disk as prior-run evidence. That matches the
+ * documented lifecycle used by astroshot-capture and the movie harness.
+ */
+export function writeDemo(options = {}) {
+  const plan = planDemo(options);
+  fs.mkdirSync(plan.featureDirectory, { recursive: true });
+  for (const { source, destination } of plan.copies) {
+    copyAtomic(source, destination);
+  }
+  writeAtomic(plan.manifestPath, `${JSON.stringify(plan.manifest, null, 2)}\n`);
+  return publicDemoResult(plan);
+}
+
 function coverageAdvice(root) {
   const configuration = readWatchConfiguration();
   const coverage = evaluateWatchCoverage(root, configuration);
@@ -231,7 +269,13 @@ function coverageAdvice(root) {
 }
 
 export function runDemo(argv, { log = console.log } = {}) {
-  const options = { feature: DEFAULT_DEMO_FEATURE, root: undefined, json: false };
+  const options = {
+    feature: DEFAULT_DEMO_FEATURE,
+    root: undefined,
+    json: false,
+    dryRun: false,
+    clean: false,
+  };
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index];
     if (token === "-h" || token === "--help" || token === "help") {
@@ -242,6 +286,14 @@ export function runDemo(argv, { log = console.log } = {}) {
       options.json = true;
       continue;
     }
+    if (token === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    if (token === "--clean") {
+      options.clean = true;
+      continue;
+    }
     if (token === "--feature" || token === "--root") {
       const value = argv[index + 1];
       if (!value || value.startsWith("-")) {
@@ -254,18 +306,22 @@ export function runDemo(argv, { log = console.log } = {}) {
     throw new Error(`Unknown demo argument: ${token}`);
   }
 
-  const result = writeDemo(options);
+  const result = options.dryRun
+    ? publicDemoResult(planDemo(options))
+    : writeDemo(options);
   if (options.json) {
     log(JSON.stringify({ ...result, advice: coverageAdvice(result.root) }, null, 2));
     return 0;
   }
 
-  const movies = result.shots.filter((shot) => shot.kind === "movie").length;
-  const stills = result.shots.length - movies;
   log(`astroshot demo → ${result.featureDirectory}`);
   for (const file of result.files) {
     log(`  ${path.relative(result.root, file)}`);
   }
+  if (options.dryRun) return 0;
+
+  const movies = result.shots.filter((shot) => shot.kind === "movie").length;
+  const stills = result.shots.length - movies;
   log("");
   log(
     `Wrote ${stills} still${stills === 1 ? "" : "s"}, ${movies} movie${movies === 1 ? "" : "s"} (poster + video), and manifest.json.`,

package/node_modules/@archastro/astroshot/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archastro/astroshot",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "One CLI for deterministic React, terminal, and movie UI captures",
   "keywords": [
     "react",
@@ -72,8 +72,9 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@archastro/movie-harness": "0.2.1",
-    "@archastro/react-shot": "0.2.1",
-    "@archastro/tui-shot": "0.2.1"
+    "@archastro/astroshot-review": "0.2.2",
+    "@archastro/movie-harness": "0.2.2",
+    "@archastro/react-shot": "0.2.2",
+    "@archastro/tui-shot": "0.2.2"
   }
 }

package/node_modules/@archastro/astroshot-review/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ArchAstro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@archastro/astroshot-review/README.md

@@ -0,0 +1,19 @@
+# @archastro/astroshot-review
+
+The Astroshots review tray in your terminal. Streams `.astroshot/` captures
+across worktrees newest-first, draws them with the Kitty graphics protocol,
+plays movies through ffmpeg, and writes the same `review.json` Seen state and
+feedback as the macOS app.
+
+```bash
+npx astroshot review              # via the unified CLI (recommended)
+npx astroshot-review ~/projects   # this package's own bin
+```
+
+- Terminals: Ghostty, kitty, WezTerm (anything with the Kitty graphics protocol).
+  Others get labeled placeholders.
+- Movies need `ffmpeg` on `PATH`.
+- Keys: `↑↓` move · `⏎` open · `f` full screen · `s` seen · `c` feedback ·
+  `u` history · `m` movies · `1`/`2` tabs · `,` settings · `?` help · `q` quit.
+
+Full guide: [docs/review-tui.md](https://github.com/ArchAstro/astroshots/blob/main/docs/review-tui.md).

package/node_modules/@archastro/astroshot-review/bin/astroshot-review.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { main } from "../dist/cli.js";
+
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+    // main() has torn the tray down, so the event loop should drain and the
+    // process exit on its own. If a stray handle is still referenced (a
+    // socket, a pipe), don't sit invisibly in the shell forever: exit. The
+    // timer is unref'd, so it never keeps the loop alive itself.
+    setTimeout(() => process.exit(code), 1000).unref();
+  },
+  (error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  },
+);

package/node_modules/@archastro/astroshot-review/dist/cli.d.ts

@@ -0,0 +1,12 @@
+export declare function reviewHelp(): string;
+export interface ParsedArgs {
+    roots: string[];
+    graphics: boolean;
+    watch: boolean;
+    index: boolean;
+    help: boolean;
+    version: boolean;
+    rootsSource: "app" | "cli" | "cwd";
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function main(argv: string[]): Promise<number>;

package/node_modules/@archastro/astroshot-review/dist/cli.js

@@ -0,0 +1,240 @@
+import fs from "node:fs";
+import path from "node:path";
+import { render } from "ink";
+import { createElement } from "react";
+import { ReviewStore } from "./data/store.js";
+import { ImageService } from "./images/service.js";
+import { createGraphicsStdout } from "./terminal/graphics-stdout.js";
+import { HerdrSink, discoverHerdr, herdrAddress, probeHerdrSet } from "./terminal/herdr.js";
+import { ImageLayer } from "./terminal/image-layer.js";
+import { probeTerminal } from "./terminal/probe.js";
+import { App } from "./ui/app.js";
+import { ServicesContext } from "./ui/context.js";
+import { detectFfmpeg } from "./video/ffmpeg.js";
+export function reviewHelp() {
+    return `astroshot review — the Astroshots tray in your terminal
+
+Usage:
+  astroshot review [<dir>...] [options]
+
+Options:
+  --root <dir>       Folder to watch for .astroshot/ trees (repeatable)
+  --no-graphics      Skip terminal pictures (text only)
+  --no-watch         Do not follow filesystem changes
+  --no-index         Ignore the on-disk index (full scan every start)
+  -h, --help         Show this help
+
+Without roots, \`astroshot review\` uses the folders the Astroshots app
+watches (macOS) and otherwise the current directory. Images render pixel-
+perfect in Kitty-protocol terminals (Ghostty, kitty, WezTerm) and inside
+herdr (enable [experimental] kitty_graphics and reattach the client once);
+elsewhere — mosh, tmux, plain terminals — they render as truecolor
+half-block text. Movie playback needs ffmpeg on PATH.
+
+Keys: ↑↓ move · ⏎ open · f full screen · s seen · c feedback · u history ·
+      m movies · 1/2 tabs · , settings · ? help · q quit`;
+}
+export function parseArgs(argv) {
+    const parsed = { roots: [], graphics: true, watch: true, index: true, help: false, version: false, rootsSource: "cli" };
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        switch (argument) {
+            case "-h":
+            case "--help":
+                parsed.help = true;
+                break;
+            case "-v":
+            case "--version":
+                parsed.version = true;
+                break;
+            case "--no-graphics":
+                parsed.graphics = false;
+                break;
+            case "--no-watch":
+                parsed.watch = false;
+                break;
+            case "--no-index":
+                parsed.index = false;
+                break;
+            case "--root": {
+                const value = argv[index + 1];
+                if (!value)
+                    throw new Error("--root requires a directory");
+                parsed.roots.push(value);
+                index += 1;
+                break;
+            }
+            case "--roots-source": {
+                const value = argv[index + 1];
+                if (value !== "app" && value !== "cli" && value !== "cwd")
+                    throw new Error("--roots-source must be app, cli, or cwd");
+                parsed.rootsSource = value;
+                index += 1;
+                break;
+            }
+            default:
+                if (argument.startsWith("-"))
+                    throw new Error(`Unknown option: ${argument}`);
+                parsed.roots.push(argument);
+        }
+    }
+    if (parsed.roots.length === 0) {
+        parsed.roots = [process.cwd()];
+        parsed.rootsSource = "cwd";
+    }
+    return parsed;
+}
+function readVersion() {
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return packageJson.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export async function main(argv) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        console.error("");
+        console.error(reviewHelp());
+        return 1;
+    }
+    if (args.help) {
+        console.log(reviewHelp());
+        return 0;
+    }
+    if (args.version) {
+        console.log(readVersion());
+        return 0;
+    }
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        console.error("astroshot review needs an interactive terminal (stdin and stdout must be a TTY).");
+        return 1;
+    }
+    const roots = args.roots.map((root) => path.resolve(root)).filter((root) => {
+        try {
+            return fs.statSync(root).isDirectory();
+        }
+        catch {
+            console.error(`Ignoring missing folder: ${root}`);
+            return false;
+        }
+    });
+    const debugLog = process.env.ASTROSHOT_REVIEW_DEBUG
+        ? (message) => fs.appendFileSync("astroshot-review.log", `${new Date().toISOString()} ${message}\n`)
+        : null;
+    let capabilities = await probeTerminal({ stdin: process.stdin, stdout: process.stdout }, { env: args.graphics ? process.env : { ...process.env, ASTROSHOT_REVIEW_GRAPHICS: "none" } });
+    // Inside herdr, raw Kitty escapes are dropped; render through its socket
+    // graphics API instead (pixel-perfect), falling back to half-blocks with an
+    // actionable reason when herdr can't yet report the host cell size.
+    let herdrSink;
+    const herdr = args.graphics ? herdrAddress() : null;
+    if (herdr) {
+        const discovery = await discoverHerdr(herdr, {
+            onWaiting: () => debugLog?.("herdr: waiting for host cell size"),
+        });
+        if (discovery.ok && discovery.cellWidth && discovery.cellHeight) {
+            const setSupport = await probeHerdrSet(herdr);
+            if (setSupport.ok) {
+                herdrSink = new HerdrSink(herdr, (error) => debugLog?.(`herdr: ${error.message}`));
+                capabilities = {
+                    ...capabilities,
+                    graphics: "herdr",
+                    cellWidth: discovery.cellWidth,
+                    cellHeight: discovery.cellHeight,
+                    cellSource: "query",
+                    reason: undefined,
+                };
+            }
+            else {
+                // herdr can size images but not place per-image layers; half-blocks it is.
+                capabilities = { ...capabilities, reason: setSupport.reason ?? "herdr pane.graphics.set unavailable" };
+            }
+        }
+        else {
+            capabilities = { ...capabilities, reason: discovery.reason ?? capabilities.reason };
+        }
+    }
+    debugLog?.(`capabilities ${JSON.stringify(capabilities)}`);
+    const ffmpeg = detectFfmpeg();
+    const service = new ImageService();
+    const layer = new ImageLayer({
+        capabilities,
+        service,
+        herdr: herdrSink,
+        write: (data) => {
+            process.stdout.write(data);
+        },
+        onError: (src, error) => debugLog?.(`image ${src}: ${error.message}`),
+        onDebug: debugLog ? (message) => debugLog(`layer ${message}`) : undefined,
+    });
+    const store = new ReviewStore({
+        roots,
+        watch: args.watch,
+        useIndex: args.index,
+        onLog: (message) => debugLog?.(`store ${message}`),
+    });
+    void store.start();
+    const stdout = createGraphicsStdout(process.stdout, layer);
+    const services = { store, layer, service, capabilities, ffmpeg, rootsSource: args.rootsSource, version: readVersion() };
+    let cleared = false;
+    const clearPictures = () => {
+        if (cleared)
+            return;
+        cleared = true;
+        const output = layer.clear();
+        if (output)
+            process.stdout.write(output);
+        herdrSink?.dispose();
+    };
+    const instance = render(createElement(ServicesContext.Provider, { value: services }, createElement(App, { onQuit: clearPictures })), {
+        stdout,
+        stdin: process.stdin,
+        alternateScreen: true,
+        exitOnCtrlC: true,
+        patchConsole: true,
+        // Ink treats CI=true as "not interactive": no alternate screen, no key
+        // handling, frames appended instead of redrawn. The tray already refuses
+        // to run without a TTY on both ends, so a TTY is the only signal that
+        // matters — CI-flavoured shells and CI pty harnesses get the real UI.
+        interactive: true,
+    });
+    // `kill <pid>` or a closing terminal must not leave pictures or the
+    // alternate screen behind; Ink only handles Ctrl+C itself.
+    const onSignal = (signal) => {
+        clearPictures();
+        try {
+            process.stdout.write("\x1b[?1049l\x1b[?25h");
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(false);
+        }
+        catch {
+            // The terminal may already be gone.
+        }
+        instance.unmount();
+        process.exit(signal === "SIGHUP" ? 129 : 143);
+    };
+    process.once("SIGTERM", onSignal);
+    process.once("SIGHUP", onSignal);
+    process.once("SIGQUIT", onSignal);
+    process.once("SIGINT", onSignal);
+    // Last-ditch: closing the herdr sockets makes herdr drop the layers even if
+    // we never got to run a signal handler.
+    process.once("exit", () => herdrSink?.dispose());
+    try {
+        await instance.waitUntilExit();
+    }
+    finally {
+        process.off("SIGTERM", onSignal);
+        process.off("SIGHUP", onSignal);
+        clearPictures();
+        await store.dispose();
+        await service.dispose();
+    }
+    return 0;
+}

package/node_modules/@archastro/astroshot-review/dist/data/friction.d.ts

@@ -0,0 +1,22 @@
+import type { HashCache } from "./hash-cache.js";
+import type { FrictionLog, FrictionRun, FrictionStep } from "./model.js";
+export declare const PROMPT_FILE = "prompt.md";
+export declare const META_FILE = "meta.json";
+export declare const RUNS_DIR = "runs";
+export declare const LOG_FILE = "log.jsonl";
+/** Parse JSONL text into ordered steps; screenshots are resolved against `runDir`. */
+export declare function parseJsonl(text: string, runDir: string): Promise<FrictionStep[]>;
+export declare function loadRun(runDir: string, runId: string, hashes: HashCache): Promise<FrictionRun | null>;
+export declare function loadRuns(logDir: string, hashes: HashCache): Promise<FrictionRun[]>;
+export declare function loadFrictionLog(logDir: string, context: {
+    worktreePath: string;
+    worktree: string;
+}, hashes: HashCache): Promise<FrictionLog | null>;
+export declare function loadFrictionLogs(frictionDir: string, context: {
+    worktreePath: string;
+    worktree: string;
+}, hashes: HashCache): Promise<FrictionLog[]>;
+/** `MMM d · HH:mm` in local time for `yyyyMMddTHHmmssZ(-N)` run ids. */
+export declare function runDisplayTitle(runId: string): string;
+export declare function stepCountLabel(count: number): string;
+export declare function frictionStatusLabel(status: string | null): string | null;