@guanlin4924/devflow-pi 0.1.62 → 0.1.64

package/src/project-migration.ts

@@ -0,0 +1,66 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { InitializationStore } from "./initialization-store.ts";
+import type { ProjectContext } from "./project-context.ts";
+
+function hash(content: Uint8Array | string): string { return `sha256:${createHash("sha256").update(content).digest("hex")}`; }
+function relativeSource(context: ProjectContext, source: string): string {
+  const absolute = path.resolve(context.root, source); const relative = path.relative(context.root, absolute).replaceAll("\\", "/");
+  if (!relative || relative === ".." || relative.startsWith("../") || path.isAbsolute(relative)) throw new Error(`Legacy source escapes project root: ${source}`);
+  return relative;
+}
+
+export async function importLegacyInitialization(context: ProjectContext, sources: string[], requestId = `legacy-import-${randomUUID()}`): Promise<{ runId: string; snapshotId: string; imports: string[] }> {
+  if (!sources.length) throw new Error("At least one legacy source is required");
+  const documents = await Promise.all(sources.map(async source => {
+    const relative = relativeSource(context, source); const content = await readFile(path.join(context.root, relative));
+    return { relative, contentHash: hash(content), size: content.byteLength };
+  }));
+  const store = await InitializationStore.open(context);
+  try {
+    const workspace = await store.registerWorkspace();
+    const config = store.putScanConfig({ mode: "fast", repositories: [{ name: "legacy-materials", relativePath: ".", role: "other" }], requiredKinds: ["evidence"], adapterVersions: { "legacy-import": "1" } });
+    const input = store.createInputSnapshot(workspace.id, config.id, documents.map(item => ({ repository: "legacy-materials", path: item.relative, contentHash: item.contentHash, size: item.size })), true);
+    const run = store.startRun({ workspaceId: workspace.id, configId: config.id, inputSnapshotId: input.id, requestId });
+    if (!run.reused) store.recordCollection(run.id, run.leaseToken, {
+      kind: "evidence", status: "complete", adapter: "legacy-import@1",
+      facts: documents.map(item => ({ kind: "evidence" as const, objectKey: `historical:${item.relative}`, value: { sourcePath: item.relative, contentHash: item.contentHash, materialType: path.extname(item.relative).slice(1) || "text", importedAs: "historical", observed: false, approved: false }, evidenceLevel: "historical" as const, sourcePath: item.relative, sourceFingerprint: item.contentHash, extractor: "legacy-import@1", confidence: "exact" as const })),
+    });
+    const snapshot = run.reused && store.getRun(run.id)?.publishedSnapshotId
+      ? { snapshotId: String(store.getRun(run.id)!.publishedSnapshotId) }
+      : store.publishRun(run.id, run.leaseToken, { completeness: "partial", updateCurrent: false });
+    const imports = documents.map(item => store.registerHistoricalImport(workspace.id, item.relative, item.contentHash, snapshot.snapshotId));
+    const authority = store.getAuthority();
+    if (authority.authority === "legacy") store.switchAuthority("shadow", authority.revision);
+    return { runId: run.id, snapshotId: snapshot.snapshotId, imports };
+  } finally { store.close(); }
+}
+
+export async function exportInitializationSnapshot(context: ProjectContext, snapshotId: string, targetPath: string): Promise<{ path: string; contentHash: string }> {
+  const absolute = path.resolve(context.root, targetPath);
+  if (absolute !== context.root && !absolute.startsWith(`${context.root}${path.sep}`)) throw new Error("Export path escapes project root");
+  const store = await InitializationStore.open(context);
+  try {
+    const facts: unknown[] = []; let after: string | undefined; let snapshot: unknown;
+    do {
+      const page = store.queryContext({ snapshotId, after, limit: 500 }) as any; snapshot ??= page.snapshot; facts.push(...page.facts); after = page.nextCursor ?? undefined;
+      if (facts.length > 100_000) throw new Error("Snapshot export exceeds 100,000 facts");
+    } while (after);
+    const content = `${JSON.stringify({ version: 1, exportedAt: new Date().toISOString(), snapshot, facts }, null, 2)}\n`;
+    await mkdir(path.dirname(absolute), { recursive: true }); const temporary = `${absolute}.${randomUUID()}.tmp`;
+    await writeFile(temporary, content, { encoding: "utf8", flag: "wx" }); await rename(temporary, absolute);
+    return { path: absolute, contentHash: hash(content) };
+  } finally { store.close(); }
+}
+
+export async function switchInitializationAuthority(context: ProjectContext, authority: "legacy" | "shadow" | "database", expectedRevision: number, options: { compatibilityExport?: string } = {}): Promise<{ authority: string; revision: number }> {
+  const store = await InitializationStore.open(context);
+  try {
+    const current = store.getAuthority();
+    if (current.authority === "database" && authority === "legacy" && !options.compatibilityExport) throw new Error("Rollback to legacy authority requires a verified compatibility export");
+    if (options.compatibilityExport) await readFile(path.resolve(context.root, options.compatibilityExport));
+    return store.switchAuthority(authority, expectedRevision);
+  } finally { store.close(); }
+}