@doxbrix/doxloop 0.1.4 → 0.2.0

package/dist/history.d.ts

@@ -0,0 +1,106 @@
+import { type Database } from './db.js';
+import type { AgentUsage, DeploymentRecord, DoxloopProject, HistoryChangedPage, HistoryPage, HistoryRequest, HistoryRequestPage, RequestKind, RequestStatus, SyncRun, SyncState } from './types.js';
+/**
+ * Recording is deliberately narrow: the request, its outcome, and the pages it
+ * touched. Agent transcripts stay in `.doxloop/ui-job-logs`, diffs stay in
+ * `.doxloop/runs`, and page content stays in git.
+ */
+export interface StartRequestInput {
+    kind: RequestKind;
+    trigger?: SyncRun['trigger'] | 'watch';
+    requestText?: string | undefined;
+    agent?: string | undefined;
+    model?: string | undefined;
+    reasoningEffort?: string | undefined;
+}
+export interface FinishRequestInput {
+    status: RequestStatus;
+    validation?: {
+        pages: number;
+        errors: number;
+        warnings: number;
+    } | undefined;
+    pagesChanged?: number;
+    linesAdded?: number;
+    linesRemoved?: number;
+    error?: string | undefined;
+    /** Token usage across every agent session the request ran, when the agent reported it. */
+    usage?: AgentUsage | undefined;
+}
+/** Open a request row before the agent starts, so an interrupted run is still visible. */
+export declare function startRequest(root: string, input: StartRequestInput): Promise<string | undefined>;
+export declare function finishRequest(root: string, id: string | undefined, input: FinishRequestInput): Promise<void>;
+/** Page content as it stood before an agent ran, keyed by project-relative path. */
+export type PageSnapshot = ReadonlyMap<string, string>;
+export interface AuthoredPages {
+    /** Paths the agent added, rewrote, or removed. */
+    paths: Set<string>;
+    linesAdded: number;
+    linesRemoved: number;
+}
+/**
+ * Capture page content so a direct authoring run can be measured afterwards.
+ * Held in memory rather than read back from the page registry: the UI server
+ * backfills that registry on startup, which would otherwise claim the pages a
+ * still-running agent is in the middle of writing.
+ */
+export declare function snapshotPages(root: string, project?: DoxloopProject): Promise<Map<string, string>>;
+/**
+ * Record what an authoring run changed. `create` and `update` write straight to
+ * disk instead of producing a proposal, so the diff against the pre-run
+ * snapshot is the only account of which pages the request touched.
+ */
+export declare function recordAuthoredPages(root: string, requestId: string | undefined, before: PageSnapshot, project?: DoxloopProject): Promise<AuthoredPages>;
+export interface SyncRunContext {
+    requestText?: string | undefined;
+    agent?: string | undefined;
+    model?: string | undefined;
+    reasoningEffort?: string | undefined;
+    runDir?: string | undefined;
+}
+/**
+ * Mirror a proposal into history. Called on every status change, so the row
+ * survives even when the run directory is later pruned.
+ */
+export declare function recordSyncRun(root: string, run: SyncRun, context?: SyncRunContext): Promise<void>;
+/** Append the baselines a run was written against. Ignores repeats. */
+export declare function recordSourceSyncs(root: string, state: SyncState | undefined, requestId?: string): Promise<void>;
+export interface DeploymentInput {
+    target: string;
+    status: 'succeeded' | 'failed';
+    startedAt: string;
+    name?: string | undefined;
+    slug?: string | undefined;
+    visibility?: string | undefined;
+    url?: string | undefined;
+    pagesCount?: number | undefined;
+    mediaCount?: number | undefined;
+    bytes?: number | undefined;
+    pagesCreated?: number | undefined;
+    pagesUpdated?: number | undefined;
+    pagesDeleted?: number | undefined;
+    error?: string | undefined;
+}
+export declare function recordDeployment(root: string, input: DeploymentInput): Promise<void>;
+/**
+ * Reconcile the page registry with what is on disk. Content hashes make edits
+ * that bypassed Doxloop visible instead of silently absent from history.
+ */
+export declare function syncPageRegistry(root: string, project?: DoxloopProject, requestId?: string, authored?: ReadonlySet<string>): Promise<void>;
+export declare function listRequests(root: string, limit?: number): Promise<HistoryRequest[]>;
+/**
+ * The pages each request touched, keyed by request id. Attached to a request
+ * list so the workspace can show what changed without a second round trip.
+ */
+export declare function requestPages(root: string, requestIds: readonly string[]): Promise<Record<string, HistoryChangedPage[]>>;
+export declare function pageHistory(root: string, path: string, limit?: number): Promise<HistoryRequestPage[]>;
+export declare function listPages(root: string): Promise<HistoryPage[]>;
+export declare function listDeployments(root: string, limit?: number): Promise<DeploymentRecord[]>;
+/**
+ * Import the JSON state written before history existed, so an upgraded project
+ * does not start empty. Runs once; the marker keeps later commands cheap.
+ */
+export declare function backfillHistory(root: string, force?: boolean): Promise<number>;
+export declare function formatRequestHistory(requests: readonly HistoryRequest[]): string;
+export type { Database };
+//# sourceMappingURL=history.d.ts.map