@spexcode/spec-cli 0.6.5

package/dist/graphSnapshot.d.ts

@@ -0,0 +1,14 @@
+import { type BoardSnapshot } from '@spexcode/spec-core';
+export declare function boardSnapshot(): Promise<BoardSnapshot>;
+export declare const buildBoard: () => Promise<{
+    nodes: any[];
+    sessions: any[];
+    identity: import("@spexcode/spec-core").ResolvedIdentity;
+    issuesStamp: string;
+}>;
+export declare const spliceSessions: (prev: Awaited<ReturnType<typeof buildBoard>>) => Promise<{
+    nodes: any[];
+    sessions: any[];
+    identity: import("@spexcode/spec-core").ResolvedIdentity;
+    issuesStamp: string;
+}>;

package/dist/graphSnapshot.js

@@ -0,0 +1,35 @@
+import { loadSpecs } from '@spexcode/spec-core';
+import { resolveLayout } from '@spexcode/spec-core';
+import { listSessions } from './sessions.js';
+import { driftIndex, historyIndex, repoRoot } from '@spexcode/spec-core';
+import { residentForgeRevision, residentForgeState } from '@spexcode/spec-forge/resident';
+import { resolveForgeHost } from '@spexcode/spec-forge/drivers';
+import { boardThreads } from './issues.js';
+import { buildBoard as assembleBoard, spliceSessions as spliceBoardSessions } from '@spexcode/spec-core';
+import { evalContext, evalTimelines } from '@spexcode/spec-eval/evaltab';
+import { evalNodesAsync } from '@spexcode/spec-eval/scenarios';
+import { sessionEvalProjections } from '@spexcode/spec-eval/sessioneval';
+// The application adapter is the sole reader of runtime/forge state. graph.ts only receives this result.
+export async function boardSnapshot() {
+    const root = repoRoot();
+    const [specs, sessions] = await Promise.all([loadSpecs(), listSessions()]);
+    const layout = await resolveLayout({ activeSessionIds: sessions.map((session) => session.id) });
+    const nodeIds = [...new Set([
+            ...specs.map((node) => node.id),
+            ...layout.worktrees.flatMap((worktree) => (worktree.ops || []).map((op) => op.nodeId)),
+        ].filter((id) => typeof id === 'string' && id.length > 0))];
+    const { issues, stamp: issuesStamp } = boardThreads({ host: resolveForgeHost(), state: residentForgeState() }, nodeIds);
+    const [idx, hidx, evalNodes] = await Promise.all([driftIndex(root), historyIndex(root), evalNodesAsync(root)]);
+    const context = await evalContext(root, specs, idx, hidx, undefined, evalNodes);
+    const timelines = await evalTimelines(nodeIds, context);
+    return {
+        root, specs, layout, sessions, issues, issuesStamp, forgeRevision: residentForgeRevision(),
+        evalTimelines: new Map(nodeIds.map((nodeId, index) => [nodeId, timelines[index]])),
+        sessionEvalProjections: sessionEvalProjections(sessions),
+    };
+}
+export const buildBoard = async () => assembleBoard(await boardSnapshot());
+export const spliceSessions = async (prev) => {
+    const sessions = await listSessions();
+    return spliceBoardSessions(prev, sessions, sessionEvalProjections(sessions));
+};

package/dist/graphStream.d.ts

@@ -0,0 +1,85 @@
+import type { Context } from 'hono';
+import { type FSWatcher } from 'node:fs';
+type Scope = 'sessions' | 'full';
+type EvalTarget = 'all' | {
+    id?: string;
+    path?: string;
+};
+type TreeWatchCallback = (event: 'rename' | 'change', filename: string | Buffer | null) => void;
+type WatchFactory = (path: string, options: {
+    recursive?: boolean;
+}, callback: TreeWatchCallback) => FSWatcher;
+type WatchTransport = 'consolidated-recursive' | 'exact-directory';
+type TreeWatcherOptions = {
+    root: string;
+    source: string;
+    scope: Scope;
+    recursive?: boolean;
+    ignore?: (relativePath: string) => boolean;
+    watchFactory?: WatchFactory;
+    transport?: WatchTransport;
+    onInput: (event: 'rename' | 'change', relativePath: string) => void;
+    onFailure: (error: Error) => void;
+};
+export declare const consolidatedRecursiveWatch: (platform?: NodeJS.Platform) => boolean;
+export declare function graphWatcherCensus(): {
+    sources: number;
+    registrations: number;
+};
+export declare class TreeWatcherRegistry {
+    readonly root: string;
+    readonly source: string;
+    readonly scope: Scope;
+    readonly transport: WatchTransport;
+    private readonly recursive;
+    private readonly ignore;
+    private readonly watchFactory;
+    private readonly onInput;
+    private readonly onFailure;
+    private readonly handles;
+    private refreshImmediate;
+    private failed;
+    constructor(options: TreeWatcherOptions);
+    get size(): number;
+    paths(): string[];
+    private get consolidated();
+    private desiredDirectories;
+    private closeHandles;
+    private sourceError;
+    private fail;
+    private scheduleRefresh;
+    refresh(): boolean;
+    close(): void;
+}
+export type PendingGraphChanges = {
+    full: boolean;
+    sessions: boolean;
+};
+export declare const addPendingGraphChange: (pending: PendingGraphChanges, scope: Scope) => PendingGraphChanges;
+export declare function isSessionCreateCandidateRegistryEvent(relativePath: string, candidatePaths: Iterable<string>): boolean;
+export declare const notifyBoardChanged: (scope?: Scope) => void;
+type RegistryGroup = {
+    root: string;
+    close(): void;
+};
+export declare function evalTargetForRef(ref: string | undefined, base: string, branches: Map<string, string>): EvalTarget | undefined;
+export declare function watchSessionEvalRefs(common: string, onInput: (ref?: string) => void, onFailure: (error: Error) => void): RegistryGroup;
+type WorktreeWatch = {
+    path: string;
+    root: TreeWatcherRegistry;
+    index: TreeWatcherRegistry;
+    close(): void;
+};
+export declare const ignoredProjectRootPath: (file: string) => boolean;
+export declare function watchSessionEvalWorktree(wtPath: string, gitDir: string, onInput: () => void, onFailure: (error: Error) => void): WorktreeWatch;
+export declare function sessionWorktreeWatchPaths(sessions: {
+    id: string;
+    path: string;
+    liveness?: string;
+}[], forcedSessions?: Set<string>): Set<string>;
+export declare function flushDeferredWorktreeRegistryChange(): void;
+export declare function watchSessionEvalRegistry(dir: string, onInput: (event: 'rename' | 'change', relativePath: string) => void, onFailure: (error: Error) => void): TreeWatcherRegistry;
+export declare function ensureBoardFileWatchers(forceSessionId?: string): Promise<void>;
+export declare function closeBoardFileWatchers(): void;
+export declare function boardStream(c: Context): Promise<Response>;
+export {};