astroshot 0.2.1 → 0.2.2

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

@@ -0,0 +1,278 @@
+/**
+ * Friction logs: `.astroshot/friction-logs/<slug>/{prompt.md,meta.json,runs/<run>/log.jsonl}`.
+ * Mirrors the macOS loader, including field aliases and silent skipping of
+ * malformed lines and missing screenshots.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { humanize, worktreeShort } from "./paths.js";
+import { entryNeedsHash, readReviewDocument, scopedEntry, snapshotFromEntry, } from "./review-store.js";
+export const PROMPT_FILE = "prompt.md";
+export const META_FILE = "meta.json";
+export const RUNS_DIR = "runs";
+export const LOG_FILE = "log.jsonl";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringList(value) {
+    if (Array.isArray(value)) {
+        return value
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    return [];
+}
+function firstString(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string")
+            return value;
+    }
+    return null;
+}
+async function exists(filePath) {
+    try {
+        await fs.promises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectoryEntry(parent, entry) {
+    if (entry.isDirectory())
+        return true;
+    if (!entry.isSymbolicLink())
+        return false;
+    try {
+        return (await fs.promises.stat(path.join(parent, entry.name))).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function mtimeOf(filePath) {
+    try {
+        return (await fs.promises.stat(filePath)).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse JSONL text into ordered steps; screenshots are resolved against `runDir`. */
+export async function parseJsonl(text, runDir) {
+    const steps = [];
+    let index = 0;
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(parsed))
+            continue;
+        index += 1;
+        const step = typeof parsed.step === "number" ? parsed.step : index;
+        const stepId = firstString(parsed, "id") ?? `step-${step}`;
+        const screenshots = [];
+        for (const name of stringList(parsed.screenshots ?? parsed.screenshot)) {
+            const byBasename = path.join(runDir, path.basename(name));
+            const asWritten = path.resolve(runDir, name);
+            if (await exists(byBasename))
+                screenshots.push(byBasename);
+            else if (await exists(asWritten))
+                screenshots.push(asWritten);
+        }
+        steps.push({
+            id: `${step}-${stepId}`,
+            step,
+            stepId,
+            title: firstString(parsed, "title") ?? humanize(stepId),
+            description: firstString(parsed, "description") ?? "",
+            transcript: firstString(parsed, "transcript", "narration", "voiceover") ?? "",
+            screenshots,
+            good: stringList(parsed.good ?? parsed.looks_good),
+            improve: stringList(parsed.improve ?? parsed.can_improve ?? parsed.improvements),
+            url: firstString(parsed, "url"),
+            capturedAt: firstString(parsed, "captured_at"),
+        });
+    }
+    return steps.sort((a, b) => a.step - b.step);
+}
+async function runReview(runDir, runId, hashes) {
+    const logPath = path.join(runDir, LOG_FILE);
+    let document;
+    try {
+        document = await readReviewDocument(runDir);
+    }
+    catch {
+        return null;
+    }
+    if (!document)
+        return null;
+    const entry = scopedEntry(document, LOG_FILE, runId);
+    let sha = null;
+    if (entryNeedsHash(entry)) {
+        try {
+            sha = await hashes.hash(logPath);
+        }
+        catch {
+            sha = null;
+        }
+    }
+    return snapshotFromEntry(entry, sha);
+}
+export async function loadRun(runDir, runId, hashes) {
+    const logPath = path.join(runDir, LOG_FILE);
+    const hasLog = await exists(logPath);
+    let steps = [];
+    if (hasLog) {
+        steps = await parseJsonl(await fs.promises.readFile(logPath, "utf8"), runDir);
+    }
+    else {
+        let entries;
+        try {
+            entries = await fs.promises.readdir(runDir);
+        }
+        catch {
+            return null;
+        }
+        if (!entries.some((entry) => /\.(png|jpe?g|webp|gif)$/i.test(entry)))
+            return null;
+    }
+    const capturedAt = (await mtimeOf(runDir)) ?? (await mtimeOf(logPath)) ?? Date.now();
+    return {
+        runId,
+        directory: runDir,
+        logPath: hasLog ? logPath : null,
+        capturedAt,
+        status: null,
+        steps,
+        review: hasLog ? await runReview(runDir, runId, hashes) : null,
+    };
+}
+export async function loadRuns(logDir, hashes) {
+    const runsDir = path.join(logDir, RUNS_DIR);
+    const runs = [];
+    let entries = [];
+    try {
+        entries = await fs.promises.readdir(runsDir, { withFileTypes: true });
+    }
+    catch {
+        entries = [];
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith(".") || !(await isDirectoryEntry(runsDir, entry)))
+            continue;
+        const run = await loadRun(path.join(runsDir, entry.name), entry.name, hashes);
+        if (run)
+            runs.push(run);
+    }
+    if (runs.length === 0 && (await exists(path.join(logDir, LOG_FILE)))) {
+        const flat = await loadRun(logDir, "latest", hashes);
+        if (flat)
+            runs.push(flat);
+    }
+    return runs.sort((a, b) => b.capturedAt - a.capturedAt);
+}
+export async function loadFrictionLog(logDir, context, hashes) {
+    const slug = path.basename(logDir);
+    const promptPath = path.join(logDir, PROMPT_FILE);
+    const metaPath = path.join(logDir, META_FILE);
+    const hasPrompt = await exists(promptPath);
+    const runs = await loadRuns(logDir, hashes);
+    if (!hasPrompt && runs.length === 0)
+        return null;
+    let meta = {};
+    try {
+        const parsed = JSON.parse(await fs.promises.readFile(metaPath, "utf8"));
+        if (isRecord(parsed))
+            meta = parsed;
+    }
+    catch {
+        meta = {};
+    }
+    const metaTitle = firstString(meta, "title")?.trim();
+    const candidates = [
+        await mtimeOf(logDir),
+        hasPrompt ? await mtimeOf(promptPath) : null,
+        await mtimeOf(metaPath),
+        runs[0]?.capturedAt ?? null,
+        typeof meta.updated_at === "string" ? Date.parse(meta.updated_at) : null,
+    ].filter((value) => typeof value === "number" && Number.isFinite(value));
+    return {
+        id: `${context.worktreePath}::${slug}`,
+        slug,
+        directory: logDir,
+        worktreePath: context.worktreePath,
+        worktree: context.worktree,
+        worktreeShort: worktreeShort(context.worktree),
+        title: metaTitle || humanize(slug),
+        description: firstString(meta, "description") ?? "",
+        status: firstString(meta, "status") ?? runs[0]?.status ?? null,
+        updatedAt: candidates.length ? Math.max(...candidates) : Date.now(),
+        promptPath: hasPrompt ? promptPath : null,
+        runs,
+    };
+}
+export async function loadFrictionLogs(frictionDir, context, hashes) {
+    let entries;
+    try {
+        entries = await fs.promises.readdir(frictionDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const logs = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith(".") || !(await isDirectoryEntry(frictionDir, entry)))
+            continue;
+        const log = await loadFrictionLog(path.join(frictionDir, entry.name), context, hashes);
+        if (log)
+            logs.push(log);
+    }
+    return logs.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+/** `MMM d · HH:mm` in local time for `yyyyMMddTHHmmssZ(-N)` run ids. */
+export function runDisplayTitle(runId) {
+    const match = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z(?:-\d+)?$/.exec(runId);
+    if (match) {
+        const date = new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4]), Number(match[5]), Number(match[6])));
+        const month = date.toLocaleString("en-US", { month: "short" });
+        const hours = String(date.getHours()).padStart(2, "0");
+        const minutes = String(date.getMinutes()).padStart(2, "0");
+        return `${month} ${date.getDate()} · ${hours}:${minutes}`;
+    }
+    return runId.length > 16 ? runId.slice(-14) : runId;
+}
+export function stepCountLabel(count) {
+    return count === 1 ? "1 step" : `${count} steps`;
+}
+export function frictionStatusLabel(status) {
+    switch ((status ?? "").toLowerCase()) {
+        case "draft":
+            return "Draft";
+        case "ready":
+            return "Ready";
+        case "running":
+            return "Running";
+        case "complete":
+        case "completed":
+        case "done":
+            return "Complete";
+        case "failed":
+        case "fail":
+        case "error":
+            return "Failed";
+        default:
+            return status ? humanize(status) : null;
+    }
+}

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

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+export interface HashRecord {
+    mtimeMs: number;
+    size: number;
+    sha256: string;
+}
+/** Memoizes file hashes by (path, mtime, size) so rescans stay cheap. */
+export declare class HashCache {
+    private readonly records;
+    private readonly inFlight;
+    constructor(initial?: Record<string, HashRecord>);
+    hash(filePath: string, stat?: fs.Stats): Promise<string>;
+    seed(records: Record<string, HashRecord>): void;
+    /** Drop records for files that are no longer part of the stream. */
+    retain(keep: Set<string>, alsoKeep?: (filePath: string) => boolean): void;
+    toJSON(): Record<string, HashRecord>;
+}

package/node_modules/@archastro/astroshot-review/dist/data/hash-cache.js

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import { sha256File } from "./review-store.js";
+/** Memoizes file hashes by (path, mtime, size) so rescans stay cheap. */
+export class HashCache {
+    records = new Map();
+    inFlight = new Map();
+    constructor(initial = {}) {
+        for (const [filePath, record] of Object.entries(initial)) {
+            this.records.set(filePath, record);
+        }
+    }
+    async hash(filePath, stat) {
+        const info = stat ?? (await fs.promises.stat(filePath));
+        const cached = this.records.get(filePath);
+        if (cached && cached.mtimeMs === info.mtimeMs && cached.size === info.size) {
+            return cached.sha256;
+        }
+        const pending = this.inFlight.get(filePath);
+        if (pending)
+            return pending;
+        const job = sha256File(filePath).then((sha256) => {
+            this.records.set(filePath, { mtimeMs: info.mtimeMs, size: info.size, sha256 });
+            this.inFlight.delete(filePath);
+            return sha256;
+        });
+        this.inFlight.set(filePath, job);
+        try {
+            return await job;
+        }
+        catch (error) {
+            this.inFlight.delete(filePath);
+            throw error;
+        }
+    }
+    seed(records) {
+        for (const [filePath, record] of Object.entries(records)) {
+            if (!this.records.has(filePath))
+                this.records.set(filePath, record);
+        }
+    }
+    /** Drop records for files that are no longer part of the stream. */
+    retain(keep, alsoKeep = () => false) {
+        for (const filePath of [...this.records.keys()]) {
+            if (!keep.has(filePath) && !alsoKeep(filePath))
+                this.records.delete(filePath);
+        }
+    }
+    toJSON() {
+        return Object.fromEntries(this.records);
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { HashRecord } from "./hash-cache.js";
+export interface IndexDocument {
+    version: 1;
+    roots: string[];
+    astroshotDirs: string[];
+    arrivalOrder: string[];
+    hashes: Record<string, HashRecord>;
+    updatedAt: string;
+    /** When the last deep walk of every root finished (ISO), if ever. */
+    fullScanAt?: string;
+}
+export declare function indexCachePath(env?: NodeJS.ProcessEnv): string;
+export declare function loadIndex(roots: string[], filePath?: string): Promise<IndexDocument | null>;
+export declare function saveIndex(document: IndexDocument, filePath?: string): Promise<void>;
+/**
+ * Keep known paths in their prior relative order; new paths go first, sorted
+ * newest capture first. Paths that vanished are dropped.
+ */
+export declare function reconcileArrivalOrder(previous: string[], shots: Array<{
+    path: string;
+    capturedAt: number;
+}>): string[];

package/node_modules/@archastro/astroshot-review/dist/data/index-cache.js

@@ -0,0 +1,64 @@
+/**
+ * Durable index so the tray opens instantly: known `.astroshot` directories,
+ * the newest-first arrival order, and memoized image hashes.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function indexCachePath(env = process.env) {
+    if (env.ASTROSHOT_REVIEW_CACHE_DIR)
+        return path.join(env.ASTROSHOT_REVIEW_CACHE_DIR, "index.json");
+    const base = env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+    return path.join(base, "astroshot-review", "index.json");
+}
+function normalizedRoots(roots) {
+    return [...roots].sort();
+}
+export async function loadIndex(roots, filePath = indexCachePath()) {
+    let raw;
+    try {
+        raw = await fs.promises.readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 || !Array.isArray(parsed.roots))
+            return null;
+        if (JSON.stringify(normalizedRoots(parsed.roots)) !== JSON.stringify(normalizedRoots(roots)))
+            return null;
+        return {
+            version: 1,
+            roots: parsed.roots,
+            astroshotDirs: Array.isArray(parsed.astroshotDirs) ? parsed.astroshotDirs : [],
+            arrivalOrder: Array.isArray(parsed.arrivalOrder) ? parsed.arrivalOrder : [],
+            hashes: parsed.hashes && typeof parsed.hashes === "object" ? parsed.hashes : {},
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : "",
+            fullScanAt: typeof parsed.fullScanAt === "string" ? parsed.fullScanAt : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveIndex(document, filePath = indexCachePath()) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    const temp = `${filePath}.${process.pid}.tmp`;
+    await fs.promises.writeFile(temp, JSON.stringify(document));
+    await fs.promises.rename(temp, filePath);
+}
+/**
+ * Keep known paths in their prior relative order; new paths go first, sorted
+ * newest capture first. Paths that vanished are dropped.
+ */
+export function reconcileArrivalOrder(previous, shots) {
+    const present = new Map(shots.map((shot) => [shot.path, shot.capturedAt]));
+    const kept = previous.filter((entry) => present.has(entry));
+    const known = new Set(kept);
+    const fresh = shots
+        .filter((shot) => !known.has(shot.path))
+        .sort((a, b) => b.capturedAt - a.capturedAt)
+        .map((shot) => shot.path);
+    return [...fresh, ...kept];
+}

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

@@ -0,0 +1,41 @@
+import type { Chapter, FeatureStatus } from "./model.js";
+export interface ManifestChapter {
+    slug?: string;
+    title?: string;
+    t_ms?: number;
+    tMs?: number;
+}
+export interface ManifestShot {
+    id?: string;
+    file?: string;
+    slug?: string;
+    title?: string;
+    description?: string;
+    captured_at?: string;
+    url?: string;
+    viewport?: unknown;
+    kind?: string;
+    video?: string;
+    poster?: string;
+    duration_ms?: number;
+    source?: string;
+    chapters?: ManifestChapter[];
+}
+export interface FeatureManifest {
+    version?: number;
+    feature?: string;
+    run_id?: string;
+    status?: string;
+    description?: string;
+    shots?: ManifestShot[];
+}
+export declare function readManifest(featureDir: string): Promise<FeatureManifest | null>;
+/** First match wins: file, poster, id (sequence), slug. */
+export declare function matchManifestShot(manifest: FeatureManifest | null, fileName: string): ManifestShot | null;
+export declare function parseFeatureStatus(raw: string | undefined | null): FeatureStatus | null;
+export declare function parseIsoDate(value: string | undefined | null): number | null;
+export declare function chaptersOf(entry: ManifestShot | null): Chapter[];
+/** `2.8s` under a minute, `m:ss` above; null when unknown. */
+export declare function durationLabel(durationMs: number | null | undefined): string | null;
+/** Chapter timestamp label used by the detail card. */
+export declare function chapterTimeLabel(tMs: number | undefined): string;

package/node_modules/@archastro/astroshot-review/dist/data/manifest.js

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import { sequenceAndSlug } from "./paths.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export async function readManifest(featureDir) {
+    let raw;
+    try {
+        raw = await fs.promises.readFile(path.join(featureDir, "manifest.json"), "utf8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed))
+            return null;
+        const manifest = parsed;
+        if (manifest.shots !== undefined && !Array.isArray(manifest.shots))
+            manifest.shots = [];
+        return manifest;
+    }
+    catch {
+        return null;
+    }
+}
+/** First match wins: file, poster, id (sequence), slug. */
+export function matchManifestShot(manifest, fileName) {
+    const shots = manifest?.shots ?? [];
+    if (shots.length === 0)
+        return null;
+    const { sequence, slug } = sequenceAndSlug(fileName);
+    return (shots.find((shot) => shot.file === fileName) ??
+        shots.find((shot) => shot.poster === fileName) ??
+        (sequence ? shots.find((shot) => shot.id === sequence) : undefined) ??
+        shots.find((shot) => shot.slug === slug) ??
+        null);
+}
+export function parseFeatureStatus(raw) {
+    switch ((raw ?? "").toLowerCase()) {
+        case "running":
+        case "run":
+        case "in_progress":
+        case "in-progress":
+            return "running";
+        case "pass":
+        case "passed":
+        case "ok":
+        case "success":
+            return "pass";
+        case "fail":
+        case "failed":
+        case "error":
+            return "fail";
+        case "idle":
+        case "pending":
+            return "idle";
+        default:
+            return null;
+    }
+}
+export function parseIsoDate(value) {
+    if (!value)
+        return null;
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? time : null;
+}
+export function chaptersOf(entry) {
+    if (!entry?.chapters || !Array.isArray(entry.chapters))
+        return [];
+    return entry.chapters.filter(isRecord).map((chapter) => ({
+        slug: typeof chapter.slug === "string" ? chapter.slug : undefined,
+        title: typeof chapter.title === "string" ? chapter.title : undefined,
+        tMs: typeof chapter.t_ms === "number"
+            ? chapter.t_ms
+            : typeof chapter.tMs === "number"
+                ? chapter.tMs
+                : undefined,
+    }));
+}
+/** `2.8s` under a minute, `m:ss` above; null when unknown. */
+export function durationLabel(durationMs) {
+    if (durationMs === null || durationMs === undefined || durationMs <= 0)
+        return null;
+    const seconds = durationMs / 1000;
+    if (seconds < 60) {
+        const rounded = Math.round(seconds * 10) / 10;
+        return Number.isInteger(rounded) ? `${rounded}s` : `${rounded.toFixed(1)}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const rest = Math.floor(seconds % 60);
+    return `${minutes}:${String(rest).padStart(2, "0")}`;
+}
+/** Chapter timestamp label used by the detail card. */
+export function chapterTimeLabel(tMs) {
+    if (tMs === undefined || tMs < 0)
+        return "—";
+    const seconds = tMs / 1000;
+    if (seconds < 60)
+        return `${seconds.toFixed(1)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const rest = Math.floor(seconds % 60);
+    return `${minutes}:${String(rest).padStart(2, "0")}`;
+}

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

@@ -0,0 +1,96 @@
+export type FeatureStatus = "running" | "pass" | "fail" | "idle";
+export interface Chapter {
+    slug?: string;
+    title?: string;
+    tMs?: number;
+}
+export interface ReviewComment {
+    id: string;
+    body: string;
+    createdAt: string;
+}
+export type ReviewState = "seen" | "pending";
+export interface ReviewSnapshot {
+    state: ReviewState;
+    /** Raw decision from disk, before hash scoping. */
+    decision: string | null;
+    hashMatches: boolean;
+    /** A decision exists but the bytes changed since it was recorded. */
+    isStale: boolean;
+    comments: ReviewComment[];
+    reviewedAt: string | null;
+}
+export interface Shot {
+    /** Absolute image path; stable identity. */
+    id: string;
+    path: string;
+    fileName: string;
+    worktreePath: string;
+    worktree: string;
+    worktreeShort: string;
+    feature: string;
+    featureDir: string;
+    sequence: string | null;
+    slug: string;
+    title: string;
+    description: string;
+    url: string | null;
+    runId: string | null;
+    status: FeatureStatus | null;
+    /** Epoch milliseconds. */
+    capturedAt: number;
+    mtimeMs: number;
+    isMovie: boolean;
+    videoFileName: string | null;
+    /** Absolute path when the video exists on disk. */
+    videoPath: string | null;
+    durationMs: number | null;
+    source: string | null;
+    chapters: Chapter[];
+    review: ReviewSnapshot | null;
+}
+export interface FrictionStep {
+    id: string;
+    step: number;
+    stepId: string;
+    title: string;
+    description: string;
+    transcript: string;
+    /** Absolute paths that exist on disk. */
+    screenshots: string[];
+    good: string[];
+    improve: string[];
+    url: string | null;
+    capturedAt: string | null;
+}
+export interface FrictionRun {
+    runId: string;
+    directory: string;
+    logPath: string | null;
+    capturedAt: number;
+    status: string | null;
+    steps: FrictionStep[];
+    review: ReviewSnapshot | null;
+}
+export interface FrictionLog {
+    /** `<worktreePath>::<slug>` */
+    id: string;
+    slug: string;
+    directory: string;
+    worktreePath: string;
+    worktree: string;
+    worktreeShort: string;
+    title: string;
+    description: string;
+    status: string | null;
+    updatedAt: number;
+    promptPath: string | null;
+    runs: FrictionRun[];
+}
+export interface AstroshotTree {
+    astroshotDir: string;
+    worktreePath: string;
+    worktree: string;
+    shots: Shot[];
+    frictionLogs: FrictionLog[];
+}

package/node_modules/@archastro/astroshot-review/dist/data/model.js

@@ -0,0 +1 @@
+export {};