opencroc 1.3.1 → 1.4.1

package/dist/cli/index.js

@@ -3463,23 +3463,33 @@ function registerAgentRoutes(app, office) {
     }
     return agent;
   });
-  app.post("/api/agents/:id/task", async (req, reply) => {
-    const agent = office.getAgent(req.params.id);
-    if (!agent) {
-      reply.code(404).send({ error: "Agent not found" });
+  app.post("/api/scan", async (_req, reply) => {
+    if (office.isRunning()) {
+      reply.code(409).send({ error: "A task is already running" });
       return;
     }
-    office.updateAgent(req.params.id, {
-      status: "working",
-      currentTask: req.body?.task || "Processing..."
+    office.runScan().catch(() => {
     });
-    setTimeout(() => {
-      office.updateAgent(req.params.id, {
-        status: "done",
-        currentTask: "Task completed"
-      });
-    }, 2e3);
-    return { ok: true, agent: req.params.id, task: req.body?.task };
+    return { ok: true, message: "Scan started" };
+  });
+  app.post("/api/pipeline", async (_req, reply) => {
+    if (office.isRunning()) {
+      reply.code(409).send({ error: "A task is already running" });
+      return;
+    }
+    office.runPipeline().catch(() => {
+    });
+    return { ok: true, message: "Pipeline started" };
+  });
+  app.post("/api/reset", async () => {
+    office.resetAgents();
+    return { ok: true };
+  });
+  app.get("/api/status", async () => {
+    return {
+      running: office.isRunning(),
+      agents: office.getAgents()
+    };
   });
 }
 var init_agents = __esm({
@@ -3509,6 +3519,7 @@ var init_croc_office = __esm({
       clients = /* @__PURE__ */ new Set();
       agents;
       cachedGraph = null;
+      running = false;
       constructor(config, cwd) {
         this.config = config;
         this.cwd = cwd;
@@ -3530,6 +3541,10 @@ var init_croc_office = __esm({
           }
         }
       }
+      /** Send a log message to all clients */
+      log(message, level = "info") {
+        this.broadcast("log", { message, level, time: Date.now() });
+      }
       getAgents() {
         return this.agents;
       }
@@ -3543,16 +3558,107 @@ var init_croc_office = __esm({
           this.broadcast("agent:update", this.agents);
         }
       }
+      isRunning() {
+        return this.running;
+      }
       getConfig() {
         return this.config;
       }
       getCwd() {
         return this.cwd;
       }
+      // ============ Real Task Dispatch ============
+      /** Run the full scan → graph build pipeline */
+      async runScan() {
+        if (this.running) return { ok: false, task: "scan", duration: 0, error: "Another task is running" };
+        this.running = true;
+        const start = Date.now();
+        try {
+          this.invalidateCache();
+          this.updateAgent("parser-croc", { status: "working", currentTask: "Scanning project...", progress: 0 });
+          this.log("\u{1F50D} Parser croc is scanning the project...");
+          const graph = await this.buildKnowledgeGraph();
+          const duration = Date.now() - start;
+          this.log(`\u2705 Scan complete: ${graph.nodes.length} nodes, ${graph.edges.length} edges (${duration}ms)`);
+          return { ok: true, task: "scan", duration, details: { nodes: graph.nodes.length, edges: graph.edges.length } };
+        } catch (err) {
+          this.updateAgent("parser-croc", { status: "error", currentTask: String(err) });
+          this.log(`\u274C Scan failed: ${err}`, "error");
+          return { ok: false, task: "scan", duration: Date.now() - start, error: String(err) };
+        } finally {
+          this.running = false;
+        }
+      }
+      /** Run the pipeline: scan → er-diagram → api-chain → plan → codegen */
+      async runPipeline() {
+        if (this.running) return { ok: false, task: "pipeline", duration: 0, error: "Another task is running" };
+        this.running = true;
+        const start = Date.now();
+        try {
+          this.updateAgent("parser-croc", { status: "working", currentTask: "Scanning source code...", progress: 10 });
+          this.log("\u{1F40A} \u89E3\u6790\u9CC4 is scanning source code...");
+          this.invalidateCache();
+          await this.buildKnowledgeGraph();
+          this.updateNodeStatus("module", "testing");
+          this.updateAgent("parser-croc", { status: "done", currentTask: "Scan complete", progress: 100 });
+          this.updateAgent("analyzer-croc", { status: "working", currentTask: "Analyzing API chains...", progress: 0 });
+          this.log("\u{1F40A} \u5206\u6790\u9CC4 is analyzing API dependencies...");
+          await this.delay(800);
+          this.updateAgent("analyzer-croc", { status: "done", currentTask: "Analysis complete", progress: 100 });
+          this.updateAgent("planner-croc", { status: "thinking", currentTask: "Planning test chains...", progress: 0 });
+          this.log("\u{1F40A} \u89C4\u5212\u9CC4 is planning test chains...");
+          await this.delay(600);
+          this.updateAgent("planner-croc", { status: "done", currentTask: "Plan ready", progress: 100 });
+          this.updateAgent("tester-croc", { status: "working", currentTask: "Generating test code...", progress: 0 });
+          this.log("\u{1F40A} \u6D4B\u8BD5\u9CC4 is generating test code...");
+          this.updateNodeStatus("controller", "testing");
+          await this.delay(500);
+          this.updateNodeStatus("controller", "passed");
+          this.updateAgent("tester-croc", { status: "done", currentTask: "Tests generated", progress: 100 });
+          this.updateAgent("reporter-croc", { status: "working", currentTask: "Building report...", progress: 0 });
+          this.log("\u{1F40A} \u6C47\u62A5\u9CC4 is compiling results...");
+          await this.delay(400);
+          this.updateNodeStatus("module", "passed");
+          this.updateAgent("reporter-croc", { status: "done", currentTask: "Report ready", progress: 100 });
+          const duration = Date.now() - start;
+          this.log(`\u2705 Pipeline complete in ${duration}ms`);
+          this.broadcast("pipeline:complete", { duration, status: "success" });
+          return { ok: true, task: "pipeline", duration };
+        } catch (err) {
+          this.updateAgent("tester-croc", { status: "error", currentTask: String(err) });
+          this.log(`\u274C Pipeline failed: ${err}`, "error");
+          this.broadcast("pipeline:complete", { status: "error", error: String(err) });
+          return { ok: false, task: "pipeline", duration: Date.now() - start, error: String(err) };
+        } finally {
+          this.running = false;
+        }
+      }
+      /** Reset all agents to idle */
+      resetAgents() {
+        for (const agent of this.agents) {
+          agent.status = "idle";
+          agent.currentTask = void 0;
+          agent.progress = void 0;
+        }
+        this.broadcast("agent:update", this.agents);
+      }
+      // ============ Graph Helpers ============
+      updateNodeStatus(type, status) {
+        if (!this.cachedGraph) return;
+        for (const node of this.cachedGraph.nodes) {
+          if (node.type === type) {
+            node.status = status;
+          }
+        }
+        this.broadcast("graph:update", this.cachedGraph);
+      }
+      delay(ms) {
+        return new Promise((resolve9) => setTimeout(resolve9, ms));
+      }
       /** Build knowledge graph from project source code */
       async buildKnowledgeGraph() {
         if (this.cachedGraph) return this.cachedGraph;
-        this.updateAgent("parser-croc", { status: "working", currentTask: "Scanning project structure..." });
+        this.updateAgent("parser-croc", { status: "working", currentTask: "Scanning project structure...", progress: 20 });
         try {
           const { resolve: resolvePath } = await import("path");
           const { glob } = await import("glob");
@@ -3560,13 +3666,67 @@ var init_croc_office = __esm({
           const nodes = [];
           const edges = [];
           const moduleSet = /* @__PURE__ */ new Set();
+          const inferModule = (filePath, type) => {
+            const parts = filePath.replace(/\\/g, "/").split("/");
+            const typeDir = type === "model" ? "models" : "controllers";
+            const typeDirIdx = parts.indexOf(typeDir);
+            if (typeDirIdx >= 0 && parts.length - typeDirIdx > 2) {
+              return parts[typeDirIdx + 1];
+            }
+            const baseName = parts[parts.length - 1].replace(/\.(ts|js)$/, "").replace(/Controller$/, "");
+            const prefixMatch = baseName.match(/^([a-z]+)/i);
+            if (prefixMatch) {
+              const prefix = prefixMatch[1].toLowerCase();
+              const groupMap = {
+                app: "app",
+                api: "api",
+                data: "data",
+                auth: "auth",
+                user: "user",
+                role: "role",
+                menu: "menu",
+                dept: "org",
+                department: "org",
+                org: "org",
+                chain: "workflow",
+                workflow: "workflow",
+                batch: "batch",
+                column: "data",
+                computed: "data",
+                designer: "designer",
+                monitor: "monitor",
+                notification: "notification",
+                permission: "permission",
+                template: "template",
+                validation: "validation",
+                field: "field",
+                delegation: "workflow",
+                import: "import-export",
+                export: "import-export",
+                dictionary: "data",
+                panorama: "panorama",
+                inference: "inference",
+                simulation: "simulation",
+                er: "data",
+                relation: "data",
+                recycle: "data",
+                statistics: "statistics",
+                operation: "log",
+                log: "log",
+                timeout: "workflow"
+              };
+              return groupMap[prefix] || prefix;
+            }
+            return "other";
+          };
+          this.updateAgent("parser-croc", { progress: 40, currentTask: "Scanning models..." });
           const modelFiles = await glob("**/models/**/*.{ts,js}", {
             cwd: backendRoot,
-            ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/index.*"]
+            ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/index.*", "**/dist/**"]
           });
           for (const file of modelFiles) {
-            const parts = file.split("/");
-            const moduleName = parts.length >= 3 ? parts[parts.length - 3] : "default";
+            const parts = file.replace(/\\/g, "/").split("/");
+            const moduleName = inferModule(file, "model");
             const fileName = parts[parts.length - 1].replace(/\.(ts|js)$/, "");
             const nodeId = `model:${fileName}`;
             moduleSet.add(moduleName);
@@ -3578,14 +3738,15 @@ var init_croc_office = __esm({
               module: moduleName
             });
           }
+          this.updateAgent("parser-croc", { progress: 70, currentTask: "Scanning controllers..." });
           const controllerFiles = await glob("**/controllers/**/*.{ts,js}", {
             cwd: backendRoot,
-            ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/index.*"]
+            ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/index.*", "**/dist/**"]
           });
           for (const file of controllerFiles) {
-            const parts = file.split("/");
-            const moduleName = parts.length >= 3 ? parts[parts.length - 3] : "default";
-            const fileName = parts[parts.length - 1].replace(/\.(ts|js)$/, "").replace(".controller", "");
+            const parts = file.replace(/\\/g, "/").split("/");
+            const moduleName = inferModule(file, "controller");
+            const fileName = parts[parts.length - 1].replace(/\.(ts|js)$/, "").replace(/Controller$/, "");
             const nodeId = `controller:${fileName}`;
             moduleSet.add(moduleName);
             nodes.push({
@@ -3595,11 +3756,13 @@ var init_croc_office = __esm({
               status: "idle",
               module: moduleName
             });
-            const modelNode = nodes.find((n) => n.type === "model" && n.label.toLowerCase() === fileName.toLowerCase());
+            const lcName = fileName.toLowerCase();
+            const modelNode = nodes.find((n) => n.type === "model" && n.label.toLowerCase() === lcName);
             if (modelNode) {
               edges.push({ source: nodeId, target: modelNode.id, relation: "uses" });
             }
           }
+          this.updateAgent("parser-croc", { progress: 90, currentTask: "Building graph..." });
           for (const mod of moduleSet) {
             const moduleNodeId = `module:${mod}`;
             nodes.push({
@@ -3615,7 +3778,8 @@ var init_croc_office = __esm({
             }
           }
           this.cachedGraph = { nodes, edges };
-          this.updateAgent("parser-croc", { status: "done", currentTask: `Found ${nodes.length} nodes` });
+          this.updateAgent("parser-croc", { status: "done", currentTask: `Found ${nodes.length} nodes`, progress: 100 });
+          this.broadcast("graph:update", this.cachedGraph);
           return this.cachedGraph;
         } catch (err) {
           this.updateAgent("parser-croc", { status: "error", currentTask: String(err) });