opencroc 1.8.0 → 1.8.1

package/dist/cli/index.js

@@ -6324,8 +6324,222 @@ var init_insight = __esm({
   }
 });
 
+// src/server/studio-store.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync6, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname6 } from "path";
+function isSerializedSnapshotFile(value) {
+  return "snapshots" in value && Array.isArray(value.snapshots);
+}
+var EMPTY_STUDIO_STORE, FileStudioSnapshotStore;
+var init_studio_store = __esm({
+  "src/server/studio-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    EMPTY_STUDIO_STORE = {
+      graph: null,
+      risks: [],
+      scanTime: 0,
+      source: ""
+    };
+    FileStudioSnapshotStore = class {
+      filePath;
+      maxSnapshots;
+      constructor(filePath, maxSnapshots = 12) {
+        this.filePath = filePath;
+        this.maxSnapshots = maxSnapshots;
+      }
+      load() {
+        const data = this.readFile();
+        if (!data || !data.currentSnapshotId) return null;
+        const current = data.snapshots.find((snapshot) => snapshot.id === data.currentSnapshotId);
+        return current ? this.toProjectStore(current) : null;
+      }
+      save(snapshot) {
+        const data = this.readFile() ?? { version: 2, currentSnapshotId: null, snapshots: [] };
+        const record = this.toSnapshotRecord(snapshot);
+        data.currentSnapshotId = record.id;
+        data.snapshots = [record, ...data.snapshots].slice(0, this.maxSnapshots);
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+      }
+      list() {
+        const data = this.readFile();
+        if (!data) return [];
+        return data.snapshots.map((snapshot) => ({
+          id: snapshot.id,
+          name: snapshot.name,
+          source: snapshot.source,
+          scanTime: snapshot.scanTime,
+          nodeCount: snapshot.graph?.nodes.length ?? 0,
+          riskCount: snapshot.risks.length,
+          current: snapshot.id === data.currentSnapshotId,
+          pinned: Boolean(snapshot.pinned),
+          tags: Array.isArray(snapshot.tags) ? snapshot.tags : []
+        })).sort((left, right) => {
+          if (left.pinned !== right.pinned) return left.pinned ? -1 : 1;
+          return right.scanTime - left.scanTime;
+        });
+      }
+      loadById(id) {
+        const data = this.readFile();
+        if (!data) return null;
+        const record = data.snapshots.find((snapshot) => snapshot.id === id);
+        if (!record) return null;
+        data.currentSnapshotId = record.id;
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return this.toProjectStore(record);
+      }
+      rename(id, name) {
+        const nextName = name.trim();
+        if (!nextName) return false;
+        const data = this.readFile();
+        if (!data) return false;
+        const record = data.snapshots.find((snapshot) => snapshot.id === id);
+        if (!record) return false;
+        record.name = nextName;
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+      }
+      delete(id) {
+        const data = this.readFile();
+        if (!data) return false;
+        const nextSnapshots = data.snapshots.filter((snapshot) => snapshot.id !== id);
+        if (nextSnapshots.length === data.snapshots.length) return false;
+        data.snapshots = nextSnapshots;
+        if (data.currentSnapshotId === id) {
+          data.currentSnapshotId = nextSnapshots[0]?.id ?? null;
+        }
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+      }
+      pin(id, pinned) {
+        const data = this.readFile();
+        if (!data) return false;
+        const record = data.snapshots.find((snapshot) => snapshot.id === id);
+        if (!record) return false;
+        record.pinned = pinned;
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+      }
+      updateTags(id, tags) {
+        const data = this.readFile();
+        if (!data) return false;
+        const record = data.snapshots.find((snapshot) => snapshot.id === id);
+        if (!record) return false;
+        record.tags = this.normalizeTags(tags);
+        mkdirSync11(dirname6(this.filePath), { recursive: true });
+        writeFileSync10(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+      }
+      readFile() {
+        if (!existsSync18(this.filePath)) return null;
+        try {
+          const raw = readFileSync6(this.filePath, "utf-8");
+          const parsed = JSON.parse(raw);
+          return this.normalize(parsed);
+        } catch {
+          return null;
+        }
+      }
+      normalize(parsed) {
+        if (isSerializedSnapshotFile(parsed)) {
+          return {
+            version: 2,
+            currentSnapshotId: typeof parsed.currentSnapshotId === "string" ? parsed.currentSnapshotId : null,
+            snapshots: parsed.snapshots.map((snapshot) => ({
+              id: snapshot.id,
+              name: snapshot.name,
+              pinned: Boolean(snapshot.pinned),
+              tags: this.normalizeTags(snapshot.tags),
+              graph: snapshot.graph ?? null,
+              risks: Array.isArray(snapshot.risks) ? snapshot.risks : [],
+              scanTime: typeof snapshot.scanTime === "number" ? snapshot.scanTime : 0,
+              source: typeof snapshot.source === "string" ? snapshot.source : ""
+            }))
+          };
+        }
+        const legacyStore = parsed;
+        const legacy = this.toSnapshotRecord({
+          graph: legacyStore.graph ?? null,
+          risks: Array.isArray(legacyStore.risks) ? legacyStore.risks : [],
+          scanTime: typeof legacyStore.scanTime === "number" ? legacyStore.scanTime : 0,
+          source: typeof legacyStore.source === "string" ? legacyStore.source : ""
+        });
+        return {
+          version: 2,
+          currentSnapshotId: legacy.id,
+          snapshots: [legacy]
+        };
+      }
+      toSnapshotRecord(snapshot) {
+        const name = snapshot.graph?.projectInfo?.name || this.deriveName(snapshot.source);
+        return {
+          id: `${snapshot.scanTime || Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+          name,
+          pinned: false,
+          tags: [],
+          graph: snapshot.graph ?? null,
+          risks: Array.isArray(snapshot.risks) ? snapshot.risks : [],
+          scanTime: typeof snapshot.scanTime === "number" ? snapshot.scanTime : Date.now(),
+          source: typeof snapshot.source === "string" ? snapshot.source : ""
+        };
+      }
+      toProjectStore(snapshot) {
+        return {
+          graph: snapshot.graph ?? null,
+          risks: Array.isArray(snapshot.risks) ? snapshot.risks : [],
+          scanTime: typeof snapshot.scanTime === "number" ? snapshot.scanTime : 0,
+          source: typeof snapshot.source === "string" ? snapshot.source : ""
+        };
+      }
+      deriveName(source) {
+        if (!source) return "unknown-project";
+        const parts = source.split(/[\\/]/).filter(Boolean);
+        return parts[parts.length - 1] || source;
+      }
+      normalizeTags(tags) {
+        if (!Array.isArray(tags)) return [];
+        return [...new Set(
+          tags.map((tag) => typeof tag === "string" ? tag.trim() : "").filter(Boolean)
+        )];
+      }
+    };
+  }
+});
+
 // src/server/routes/studio.ts
-function registerStudioRoutes(app, office) {
+function restoreStore(snapshotStore) {
+  return snapshotStore?.load() ?? { ...EMPTY_STUDIO_STORE };
+}
+function registerStudioRoutes(app, office, snapshotStore) {
+  const store = restoreStore(snapshotStore);
+  if (store.graph) {
+    office.log(`\u267B\uFE0F Restored Studio snapshot: ${store.graph.nodes.length} nodes, ${store.risks.length} risks`, "info");
+  }
+  const persistStore = () => {
+    snapshotStore?.save(store);
+  };
+  const broadcastGraph = () => {
+    if (!store.graph) return;
+    office.broadcast("graph:update", {
+      nodes: store.graph.nodes.map((n) => ({
+        id: n.id,
+        label: n.label,
+        type: n.type,
+        module: n.module,
+        status: n.status
+      })),
+      edges: store.graph.edges.map((e) => ({
+        source: e.source,
+        target: e.target,
+        relation: e.relation
+      }))
+    });
+  };
   app.post("/api/studio/scan", async (req, reply) => {
     const { target, branch, useLlm } = req.body || {};
     if (!target || typeof target !== "string") {
@@ -6364,20 +6578,8 @@ function registerStudioRoutes(app, office) {
       store.risks = risks;
       store.scanTime = Date.now();
       store.source = target;
-      office.broadcast("graph:update", {
-        nodes: graph.nodes.map((n) => ({
-          id: n.id,
-          label: n.label,
-          type: n.type,
-          module: n.module,
-          status: n.status
-        })),
-        edges: graph.edges.map((e) => ({
-          source: e.source,
-          target: e.target,
-          relation: e.relation
-        }))
-      });
+      persistStore();
+      broadcastGraph();
       return {
         ok: true,
         project: graph.projectInfo,
@@ -6511,8 +6713,120 @@ function registerStudioRoutes(app, office) {
       source: store.source
     };
   });
+  app.get("/api/studio/snapshots", async () => {
+    const snapshots = snapshotStore?.list() ?? [];
+    return {
+      total: snapshots.length,
+      snapshots
+    };
+  });
+  app.post("/api/studio/snapshots/:id/load", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const restored = snapshotStore.loadById(req.params.id);
+    if (!restored) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    store.graph = restored.graph;
+    store.risks = restored.risks;
+    store.scanTime = restored.scanTime;
+    store.source = restored.source;
+    office.log(`\u267B\uFE0F Restored snapshot: ${store.source || "unknown source"}`, "info");
+    broadcastGraph();
+    return {
+      ok: true,
+      source: store.source,
+      scanTime: store.scanTime,
+      graph: store.graph ? {
+        nodeCount: store.graph.nodes.length,
+        edgeCount: store.graph.edges.length
+      } : null,
+      risks: store.risks.length
+    };
+  });
+  app.post("/api/studio/snapshots/:id/rename", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const name = req.body?.name?.trim();
+    if (!name) {
+      reply.code(400).send({ error: "Snapshot name is required." });
+      return;
+    }
+    const renamed = snapshotStore.rename(req.params.id, name);
+    if (!renamed) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    return {
+      ok: true,
+      snapshots: snapshotStore.list()
+    };
+  });
+  app.post("/api/studio/snapshots/:id/pin", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const pinned = Boolean(req.body?.pinned);
+    const updated = snapshotStore.pin(req.params.id, pinned);
+    if (!updated) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    return {
+      ok: true,
+      snapshots: snapshotStore.list()
+    };
+  });
+  app.post("/api/studio/snapshots/:id/tags", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const rawTags = Array.isArray(req.body?.tags) ? req.body.tags : [];
+    const tags = [...new Set(
+      rawTags.map((tag) => typeof tag === "string" ? tag.trim() : "").filter(Boolean)
+    )];
+    const updated = snapshotStore.updateTags(req.params.id, tags);
+    if (!updated) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    return {
+      ok: true,
+      snapshots: snapshotStore.list()
+    };
+  });
+  app.post("/api/studio/snapshots/:id/delete", async (req, reply) => {
+    if (!snapshotStore) {
+      reply.code(501).send({ error: "Snapshot persistence is not configured." });
+      return;
+    }
+    const deleted = snapshotStore.delete(req.params.id);
+    if (!deleted) {
+      reply.code(404).send({ error: "Snapshot not found." });
+      return;
+    }
+    const current = snapshotStore.load();
+    store.graph = current?.graph ?? null;
+    store.risks = current?.risks ?? [];
+    store.scanTime = current?.scanTime ?? 0;
+    store.source = current?.source ?? "";
+    if (store.graph) {
+      broadcastGraph();
+    }
+    return {
+      ok: true,
+      hasCurrent: Boolean(current?.graph),
+      snapshots: snapshotStore.list()
+    };
+  });
 }
-var store;
 var init_studio = __esm({
   "src/server/routes/studio.ts"() {
     "use strict";
@@ -6520,12 +6834,7 @@ var init_studio = __esm({
     init_github_cloner();
     init_graph();
     init_insight();
-    store = {
-      graph: null,
-      risks: [],
-      scanTime: 0,
-      source: ""
-    };
+    init_studio_store();
   }
 });
 
@@ -6728,14 +7037,14 @@ var runtime_bootstrap_exports = {};
 __export(runtime_bootstrap_exports, {
   createRuntimeBootstrap: () => createRuntimeBootstrap
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname6, join as join16 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname7, join as join16 } from "path";
 function ensureFile(filePath, content, force) {
-  if (existsSync18(filePath) && !force) {
+  if (existsSync19(filePath) && !force) {
     return false;
   }
-  mkdirSync11(dirname6(filePath), { recursive: true });
-  writeFileSync10(filePath, content, "utf-8");
+  mkdirSync12(dirname7(filePath), { recursive: true });
+  writeFileSync11(filePath, content, "utf-8");
   return true;
 }
 function createRuntimeBootstrap(config) {
@@ -7034,13 +7343,13 @@ var init_croc_office = __esm({
           const fullResult = await pipeline.run(["scan", "er-diagram", "api-chain", "plan", "codegen"]);
           this.lastPipelineResult = fullResult;
           this.lastGeneratedFiles = fullResult.generatedFiles;
-          const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync14 } = await import("fs");
-          const { dirname: dirname8 } = await import("path");
+          const { writeFileSync: writeFileSync14, mkdirSync: mkdirSync15 } = await import("fs");
+          const { dirname: dirname9 } = await import("path");
           let filesWritten = 0;
           for (const file of fullResult.generatedFiles) {
             const fullPath = resolvePath(this.cwd, file.filePath);
-            mkdirSync14(dirname8(fullPath), { recursive: true });
-            writeFileSync13(fullPath, file.content, "utf-8");
+            mkdirSync15(dirname9(fullPath), { recursive: true });
+            writeFileSync14(fullPath, file.content, "utf-8");
             filesWritten++;
           }
           this.updateNodeStatus("controller", "passed");
@@ -7124,14 +7433,14 @@ var init_croc_office = __esm({
         let backendStatus;
         try {
           const { resolve: resolvePath } = await import("path");
-          const { existsSync: existsSync21 } = await import("fs");
+          const { existsSync: existsSync22 } = await import("fs");
           const { createExecutionCoordinator: createExecutionCoordinator2 } = await Promise.resolve().then(() => (init_coordinator(), coordinator_exports));
           const { createBackendManager: createBackendManager2 } = await Promise.resolve().then(() => (init_backend_manager(), backend_manager_exports));
           const { createRuntimeBootstrap: createRuntimeBootstrap2 } = await Promise.resolve().then(() => (init_runtime_bootstrap(), runtime_bootstrap_exports));
           const { createAuthProvisioner: createAuthProvisioner2 } = await Promise.resolve().then(() => (init_auth_provisioner(), auth_provisioner_exports));
           const { buildExecutionQualityGate: buildExecutionQualityGate2 } = await Promise.resolve().then(() => (init_quality_gate(), quality_gate_exports));
           const { categorizeFailure: categorizeFailure2 } = await Promise.resolve().then(() => (init_self_healing(), self_healing_exports));
-          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync21(f));
+          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync22(f));
           if (testFiles.length === 0) {
             this.log("\u26A0\uFE0F No test files found on disk", "warn");
             return { ok: false, task: "execute", duration: Date.now() - start, error: "No test files found on disk" };
@@ -7258,12 +7567,12 @@ var init_croc_office = __esm({
           });
           this.lastReports = reports;
           const { resolve: resolvePath } = await import("path");
-          const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync14 } = await import("fs");
+          const { writeFileSync: writeFileSync14, mkdirSync: mkdirSync15 } = await import("fs");
           const outDir = resolvePath(this.cwd, this.config.outDir || "./opencroc-output");
-          mkdirSync14(outDir, { recursive: true });
+          mkdirSync15(outDir, { recursive: true });
           for (const report2 of reports) {
             const fullPath = resolvePath(outDir, report2.filename);
-            writeFileSync13(fullPath, report2.content, "utf-8");
+            writeFileSync14(fullPath, report2.content, "utf-8");
             this.log(`\u{1F4C4} Generated ${report2.format} report: ${report2.filename}`);
           }
           this.updateAgent("reporter-croc", { status: "done", currentTask: `${reports.length} reports generated`, progress: 100 });
@@ -7508,13 +7817,13 @@ import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import fastifyWebsocket from "@fastify/websocket";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7, join as join17, resolve as resolve11 } from "path";
-import { existsSync as existsSync19 } from "fs";
+import { dirname as dirname8, join as join17, resolve as resolve11 } from "path";
+import { existsSync as existsSync20 } from "fs";
 async function startServer(opts) {
   const app = Fastify({ logger: false });
   await app.register(fastifyWebsocket);
   const webDir = resolve11(__dirname2, "../web");
-  if (existsSync19(webDir)) {
+  if (existsSync20(webDir)) {
     await app.register(fastifyStatic, {
       root: webDir,
       prefix: "/",
@@ -7522,9 +7831,10 @@ async function startServer(opts) {
     });
   }
   const office = new CrocOffice(opts.config, opts.cwd);
+  const snapshotStore = new FileStudioSnapshotStore(resolve11(opts.cwd, ".opencroc/studio-snapshot.json"));
   registerProjectRoutes(app, office);
   registerAgentRoutes(app, office);
-  registerStudioRoutes(app, office);
+  registerStudioRoutes(app, office, snapshotStore);
   app.register(async (fastify) => {
     fastify.get("/ws", { websocket: true }, (socket) => {
       office.addClient(socket);
@@ -7538,9 +7848,9 @@ async function startServer(opts) {
     }
     const studioPath = join17(webDir, "index-studio.html");
     const indexPath = join17(webDir, "index.html");
-    if (existsSync19(studioPath)) {
+    if (existsSync20(studioPath)) {
       reply.sendFile("index-studio.html");
-    } else if (existsSync19(indexPath)) {
+    } else if (existsSync20(indexPath)) {
       reply.sendFile("index.html");
     } else {
       reply.code(200).header("content-type", "text/html").send(getEmbeddedHtml());
@@ -7691,8 +8001,9 @@ var init_server = __esm({
     init_agents();
     init_studio();
     init_croc_office();
+    init_studio_store();
     __filename2 = fileURLToPath2(import.meta.url);
-    __dirname2 = dirname7(__filename2);
+    __dirname2 = dirname8(__filename2);
   }
 });