ai-discovery-manager-cli 0.1.0

package/dist/checkpoints.js

@@ -0,0 +1,134 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const RUNS_DIR = ".ai-discovery/runs";
+function makeRunId(command) {
+    const stamp = new Date()
+        .toISOString()
+        .replace(/[:.]/g, "-")
+        .replace("T", "_")
+        .replace("Z", "");
+    const suffix = Math.random().toString(36).slice(2, 8);
+    return `${command}-${stamp}-${suffix}`;
+}
+function assertRunId(runId) {
+    if (!/^[A-Za-z0-9_.-]+$/.test(runId)) {
+        throw new Error(`Invalid run id "${runId}".`);
+    }
+}
+export function checkpointDir(workspace, runId) {
+    assertRunId(runId);
+    return path.resolve(workspace, RUNS_DIR, runId);
+}
+export async function createRunCheckpoint(workspace, command, options, prompt, resumedFrom) {
+    const runId = makeRunId(command);
+    const dir = checkpointDir(workspace, runId);
+    const checkpoint = {
+        runId,
+        dir,
+        promptPath: path.join(dir, "prompt.md"),
+        optionsPath: path.join(dir, "options.json"),
+        partialPath: path.join(dir, "partial.md"),
+        finalPath: path.join(dir, "final.md"),
+        metadataPath: path.join(dir, "metadata.json"),
+        resultPath: path.join(dir, "result.json"),
+    };
+    await mkdir(dir, { recursive: true });
+    await writeFile(checkpoint.promptPath, prompt, "utf8");
+    await writeFile(checkpoint.optionsPath, `${JSON.stringify(options, null, 2)}\n`, "utf8");
+    await writeFile(checkpoint.partialPath, "", "utf8");
+    await writeMetadata(checkpoint, {
+        runId,
+        resumedFrom,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        status: "running",
+        command,
+    });
+    return checkpoint;
+}
+export async function loadRunCheckpoint(workspace, runId) {
+    const dir = checkpointDir(workspace, runId);
+    const [optionsRaw, prompt, partial, metadataRaw] = await Promise.all([
+        readFile(path.join(dir, "options.json"), "utf8"),
+        readFile(path.join(dir, "prompt.md"), "utf8"),
+        readFile(path.join(dir, "partial.md"), "utf8").catch(() => ""),
+        readFile(path.join(dir, "metadata.json"), "utf8").catch(() => undefined),
+    ]);
+    return {
+        runId,
+        dir,
+        options: JSON.parse(optionsRaw),
+        prompt,
+        partial,
+        metadata: metadataRaw
+            ? JSON.parse(metadataRaw)
+            : undefined,
+    };
+}
+export async function writePartialCheckpoint(checkpoint, partial) {
+    await writeFile(checkpoint.partialPath, partial, "utf8");
+}
+export function writePartialCheckpointSync(checkpoint, partial, status = "interrupted", error) {
+    mkdirSync(checkpoint.dir, { recursive: true });
+    writeFileSync(checkpoint.partialPath, partial, "utf8");
+    const prior = (() => {
+        try {
+            return JSON.parse(readFileSync(checkpoint.metadataPath, "utf8"));
+        }
+        catch {
+            return {};
+        }
+    })();
+    writeFileSync(checkpoint.metadataPath, `${JSON.stringify({
+        ...prior,
+        runId: checkpoint.runId,
+        updatedAt: new Date().toISOString(),
+        status,
+        error,
+    }, null, 2)}\n`, "utf8");
+}
+export async function writeMetadata(checkpoint, metadata) {
+    await writeFile(checkpoint.metadataPath, `${JSON.stringify({ ...metadata, updatedAt: new Date().toISOString() }, null, 2)}\n`, "utf8");
+}
+export async function completeRunCheckpoint(checkpoint, finalOutput, result) {
+    const usage = result.usage;
+    await writeFile(checkpoint.partialPath, finalOutput, "utf8");
+    await writeFile(checkpoint.finalPath, finalOutput, "utf8");
+    await writeFile(checkpoint.resultPath, `${JSON.stringify({
+        runId: checkpoint.runId,
+        artifactPath: result.artifactPath,
+        traceId: result.traceId,
+        usage,
+        citations: result.citations,
+    }, null, 2)}\n`, "utf8");
+    await writeMetadata(checkpoint, {
+        runId: checkpoint.runId,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        status: "completed",
+        command: result.command,
+        artifactPath: result.artifactPath,
+        traceId: result.traceId,
+        usage,
+    });
+}
+export function buildResumePrompt(checkpoint) {
+    return [
+        "Resume an interrupted AI Discovery run.",
+        "",
+        "Original prompt:",
+        checkpoint.prompt.trimEnd(),
+        "",
+        "Partial Markdown already produced:",
+        checkpoint.partial.trim()
+            ? checkpoint.partial.trimEnd()
+            : "(No partial Markdown was saved.)",
+        "",
+        "Resume instructions:",
+        "- Continue toward one coherent final artifact.",
+        "- Reuse any usable partial Markdown instead of repeating work unnecessarily.",
+        "- Repair obvious truncation at the resume boundary.",
+        "- Preserve the original citation, safety, validation, and reproducibility requirements.",
+    ].join("\n");
+}