agentic-dev 0.2.13 → 0.2.14

package/README.md

@@ -55,9 +55,10 @@ CLI는 이 순서로 동작한다.
 5. `.agentic-dev/orchestration.json` / `.agentic-dev/setup.json` write
 6. `.github/workflows/agentic-orchestration.yml` install
 7. `.agentic-dev/runtime/*.mjs` install
-8. `.env.example -> .env`
-9. `pnpm install`
-10. `app mode != backend`이면 Playwright/bootstrap
+8. `.agentic-dev/runtime/server.mjs` install
+9. `.env.example -> .env`
+10. `pnpm install`
+11. `app mode != backend`이면 Playwright/bootstrap
 
 ## Workflow Contract
 
@@ -67,10 +68,12 @@ CLI는 이 순서로 동작한다.
 - `.agentic-dev/runtime/sdd_to_ir.mjs`
 - `.agentic-dev/runtime/sync_project_tasks.mjs`
 - `.agentic-dev/runtime/run_multi_agent_queue.mjs`
+- `.agentic-dev/runtime/dispatch_agents.mjs`
 - `.agentic-dev/runtime/close_completed_tasks.mjs`
+- `.agentic-dev/runtime/server.mjs`
 - `.github/workflows/agentic-orchestration.yml`
 
-즉 SDD planning 산출물이 push되면 workflow가 task IR를 만들고, GitHub task mirror와 multi-agent queue를 갱신하는 구조다.
+즉 SDD planning 산출물이 push되면 workflow가 local orchestration server를 띄우고, 그 서버가 task IR, GitHub task mirror, multi-agent queue, dispatch plan, close pass를 처리하는 구조다.
 
 ## Non-interactive Example
 

package/lib/orchestration-assets.mjs

@@ -60,23 +60,100 @@ jobs:
         with:
           node-version: "20"
 
+      - name: Start orchestration server
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: |
+          node .agentic-dev/runtime/server.mjs > /tmp/agentic-orchestration.log 2>&1 &
+          echo $! > /tmp/agentic-orchestration.pid
+          for i in $(seq 1 30); do
+            if curl -fsS http://127.0.0.1:4310/health >/dev/null; then
+              exit 0
+            fi
+            sleep 1
+          done
+          cat /tmp/agentic-orchestration.log
+          exit 1
+
       - name: Build task IR from SDD planning
-        run: node .agentic-dev/runtime/sdd_to_ir.mjs
+        run: curl -fsS -X POST http://127.0.0.1:4310/sync/ir
 
       - name: Sync GitHub project tasks
         env:
           GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
-        run: node .agentic-dev/runtime/sync_project_tasks.mjs
+        run: curl -fsS -X POST http://127.0.0.1:4310/sync/tasks
 
       - name: Plan multi-agent queue
         env:
           GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
-        run: node .agentic-dev/runtime/run_multi_agent_queue.mjs
+        run: curl -fsS -X POST http://127.0.0.1:4310/queue/plan
+
+      - name: Build dispatch plan
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: curl -fsS -X POST http://127.0.0.1:4310/queue/dispatch
 
       - name: Close completed tasks
         env:
           GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
-        run: node .agentic-dev/runtime/close_completed_tasks.mjs
+        run: curl -fsS -X POST http://127.0.0.1:4310/tasks/close
+
+      - name: Stop orchestration server
+        if: always()
+        run: |
+          if [ -f /tmp/agentic-orchestration.pid ]; then
+            kill $(cat /tmp/agentic-orchestration.pid) || true
+          fi
+`;
+}
+
+function runtimeLibScript() {
+  return `#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+export function readJson(filePath, fallback = null) {
+  if (!fs.existsSync(filePath)) return fallback;
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+
+export function writeJson(filePath, payload) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2) + "\\n");
+}
+
+export function generatedDir() {
+  return path.resolve(".agentic-dev/generated");
+}
+
+export function generatedPath(name) {
+  return path.join(generatedDir(), name);
+}
+
+export function orchestrationConfig() {
+  return readJson(path.resolve(".agentic-dev/orchestration.json"), {});
+}
+
+export function ghJson(args) {
+  return JSON.parse(execFileSync("gh", args, { encoding: "utf-8" }));
+}
+
+export function gh(args) {
+  return execFileSync("gh", args, { encoding: "utf-8" }).trim();
+}
+
+export function loadTaskIr() {
+  return readJson(generatedPath("task-ir.json"), { tasks: [] });
+}
+
+export function loadQueue() {
+  return readJson(generatedPath("agent-queue.json"), { queue: [] });
+}
 `;
 }
 
@@ -84,6 +161,7 @@ function sddToIrScript() {
   return `#!/usr/bin/env node
 import fs from "node:fs";
 import path from "node:path";
+import { generatedPath, writeJson } from "./runtime-lib.mjs";
 
 function walk(root) {
   if (!fs.existsSync(root)) return [];
@@ -113,10 +191,8 @@ function parseChecklist(markdown, source) {
 const planRoot = path.resolve("sdd/02_plan");
 const files = walk(planRoot);
 const tasks = files.flatMap((file) => parseChecklist(fs.readFileSync(file, "utf-8"), path.relative(process.cwd(), file)));
-const outputDir = path.resolve(".agentic-dev/generated");
-fs.mkdirSync(outputDir, { recursive: true });
-const outputPath = path.join(outputDir, "task-ir.json");
-fs.writeFileSync(outputPath, JSON.stringify({ generated_at: new Date().toISOString(), tasks }, null, 2) + "\\n");
+const outputPath = generatedPath("task-ir.json");
+writeJson(outputPath, { generated_at: new Date().toISOString(), tasks });
 console.log(\`task_ir=\${outputPath}\`);
 console.log(\`tasks=\${tasks.length}\`);
 `;
@@ -124,43 +200,37 @@ console.log(\`tasks=\${tasks.length}\`);
 
 function syncProjectTasksScript() {
   return `#!/usr/bin/env node
-import fs from "node:fs";
-import { execFileSync } from "node:child_process";
-
-const orchestration = JSON.parse(fs.readFileSync(".agentic-dev/orchestration.json", "utf-8"));
-const taskIr = JSON.parse(fs.readFileSync(".agentic-dev/generated/task-ir.json", "utf-8"));
-
-function ghJson(args) {
-  return JSON.parse(execFileSync("gh", args, { encoding: "utf-8" }));
-}
-
-function gh(args) {
-  return execFileSync("gh", args, { encoding: "utf-8" }).trim();
-}
+import { gh, ghJson, loadTaskIr, orchestrationConfig, writeJson, generatedPath } from "./runtime-lib.mjs";
 
+const orchestration = orchestrationConfig();
+const taskIr = loadTaskIr();
 const existingIssues = ghJson(["issue", "list", "--repo", orchestration.github.repository.slug, "--state", "all", "--limit", "200", "--json", "number,title,state"]);
+const syncResult = { created: [], closed: [] };
 
 for (const task of taskIr.tasks) {
   const issueTitle = \`[agentic-task] \${task.id} \${task.title}\`;
   const found = existingIssues.find((issue) => issue.title.startsWith(\`[agentic-task] \${task.id} \`));
   if (!found && task.status === "open") {
-    gh(["issue", "create", "--repo", orchestration.github.repository.slug, "--title", issueTitle, "--body", \`SDD source: \${task.source}\\n\\nManaged by agentic-dev orchestration.\`, "--label", "agentic-task"]);
+    const url = gh(["issue", "create", "--repo", orchestration.github.repository.slug, "--title", issueTitle, "--body", \`SDD source: \${task.source}\\n\\nManaged by agentic-dev orchestration.\`, "--label", "agentic-task"]);
+    syncResult.created.push({ id: task.id, title: task.title, issue_url: url });
   }
   if (found && task.status === "closed" && found.state !== "CLOSED") {
     gh(["issue", "close", String(found.number), "--repo", orchestration.github.repository.slug, "--comment", "Closed from SDD task IR."]);
+    syncResult.closed.push({ id: task.id, issue_number: found.number });
   }
 }
 
+writeJson(generatedPath("task-sync.json"), syncResult);
 console.log(\`synced_tasks=\${taskIr.tasks.length}\`);
 `;
 }
 
 function runQueueScript() {
   return `#!/usr/bin/env node
-import fs from "node:fs";
+import { generatedPath, loadTaskIr, orchestrationConfig, writeJson } from "./runtime-lib.mjs";
 
-const orchestration = JSON.parse(fs.readFileSync(".agentic-dev/orchestration.json", "utf-8"));
-const taskIr = JSON.parse(fs.readFileSync(".agentic-dev/generated/task-ir.json", "utf-8"));
+const orchestration = orchestrationConfig();
+const taskIr = loadTaskIr();
 
 function classifyAgent(title) {
   const lower = title.toLowerCase();
@@ -176,37 +246,142 @@ const openTasks = taskIr.tasks.filter((task) => task.status === "open");
 const queue = openTasks.map((task) => ({
   ...task,
   assigned_agent: classifyAgent(task.title),
+  preferred_provider:
+    orchestration.providers.find((provider) => provider.startsWith("codex")) ||
+    orchestration.providers[0] ||
+    "codex-subscription",
 }));
 
-const outputPath = ".agentic-dev/generated/agent-queue.json";
-fs.writeFileSync(outputPath, JSON.stringify({ providers: orchestration.providers, queue }, null, 2) + "\\n");
+const outputPath = generatedPath("agent-queue.json");
+writeJson(outputPath, { providers: orchestration.providers, queue });
 console.log(\`agent_queue=\${outputPath}\`);
 console.log(\`queued=\${queue.length}\`);
 `;
 }
 
-function closeTasksScript() {
+function dispatchQueueScript() {
   return `#!/usr/bin/env node
-import fs from "node:fs";
-import { execFileSync } from "node:child_process";
+import { generatedPath, loadQueue, orchestrationConfig, writeJson } from "./runtime-lib.mjs";
+
+const orchestration = orchestrationConfig();
+const queuePayload = loadQueue();
+
+const dispatch = queuePayload.queue.map((task) => ({
+  task_id: task.id,
+  title: task.title,
+  assigned_agent: task.assigned_agent,
+  provider: task.preferred_provider,
+  repository: orchestration.github.repository.slug,
+  project_title: orchestration.github.project.title,
+  execution_state: "planned",
+}));
 
-const orchestration = JSON.parse(fs.readFileSync(".agentic-dev/orchestration.json", "utf-8"));
-const taskIr = JSON.parse(fs.readFileSync(".agentic-dev/generated/task-ir.json", "utf-8"));
+const outputPath = generatedPath("dispatch-plan.json");
+writeJson(outputPath, {
+  generated_at: new Date().toISOString(),
+  dispatch,
+});
+console.log(\`dispatch_plan=\${outputPath}\`);
+console.log(\`planned=\${dispatch.length}\`);
+`;
+}
+
+function closeTasksScript() {
+  return `#!/usr/bin/env node
+import { gh, ghJson, generatedPath, loadTaskIr, orchestrationConfig, writeJson } from "./runtime-lib.mjs";
 
+const orchestration = orchestrationConfig();
+const taskIr = loadTaskIr();
 const closedIds = new Set(taskIr.tasks.filter((task) => task.status === "closed").map((task) => task.id));
-const issues = JSON.parse(execFileSync("gh", ["issue", "list", "--repo", orchestration.github.repository.slug, "--state", "open", "--limit", "200", "--json", "number,title"], { encoding: "utf-8" }));
+const issues = ghJson(["issue", "list", "--repo", orchestration.github.repository.slug, "--state", "open", "--limit", "200", "--json", "number,title"]);
+const closed = [];
 
 for (const issue of issues) {
   const match = issue.title.match(/^\\[agentic-task\\] ([^ ]+) /);
   if (!match) continue;
   if (!closedIds.has(match[1])) continue;
-  execFileSync("gh", ["issue", "close", String(issue.number), "--repo", orchestration.github.repository.slug, "--comment", "Closed from SDD orchestration close pass."], { encoding: "utf-8" });
+  gh(["issue", "close", String(issue.number), "--repo", orchestration.github.repository.slug, "--comment", "Closed from SDD orchestration close pass."]);
+  closed.push({ id: match[1], issue_number: issue.number });
 }
 
+writeJson(generatedPath("closed-tasks.json"), { closed });
 console.log(\`closed_candidates=\${closedIds.size}\`);
 `;
 }
 
+function serverScript() {
+  return `#!/usr/bin/env node
+import http from "node:http";
+import { spawn } from "node:child_process";
+
+const port = Number(process.env.AGENTIC_ORCHESTRATION_PORT || 4310);
+
+function runNodeScript(script) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [script], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr || stdout || \`Script failed: \${script}\`));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+const routes = {
+  "POST /sync/ir": ".agentic-dev/runtime/sdd_to_ir.mjs",
+  "POST /sync/tasks": ".agentic-dev/runtime/sync_project_tasks.mjs",
+  "POST /queue/plan": ".agentic-dev/runtime/run_multi_agent_queue.mjs",
+  "POST /queue/dispatch": ".agentic-dev/runtime/dispatch_agents.mjs",
+  "POST /tasks/close": ".agentic-dev/runtime/close_completed_tasks.mjs",
+};
+
+const server = http.createServer(async (req, res) => {
+  const routeKey = \`\${req.method} \${req.url}\`;
+  if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, port }));
+    return;
+  }
+
+  const script = routes[routeKey];
+  if (!script) {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "not_found" }));
+    return;
+  }
+
+  try {
+    const result = await runNodeScript(script);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, stdout: result.stdout.trim() }));
+  } catch (error) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: false, error: String(error.message || error) }));
+  }
+});
+
+server.listen(port, "127.0.0.1", () => {
+  console.log(\`agentic_orchestration_server=http://127.0.0.1:\${port}\`);
+});
+`;
+}
+
 export function installSharedAgentAssets(destinationRoot) {
   const root = repoRootDir();
   copyRecursive(path.join(root, ".agent"), path.join(destinationRoot, ".agent"));
@@ -216,10 +391,13 @@ export function installSharedAgentAssets(destinationRoot) {
 
 export function installOrchestrationAssets(destinationRoot) {
   writeFile(path.join(destinationRoot, ".github/workflows/agentic-orchestration.yml"), workflowYaml());
+  writeFile(path.join(destinationRoot, ".agentic-dev/runtime/runtime-lib.mjs"), runtimeLibScript());
   writeFile(path.join(destinationRoot, ".agentic-dev/runtime/sdd_to_ir.mjs"), sddToIrScript());
   writeFile(path.join(destinationRoot, ".agentic-dev/runtime/sync_project_tasks.mjs"), syncProjectTasksScript());
   writeFile(path.join(destinationRoot, ".agentic-dev/runtime/run_multi_agent_queue.mjs"), runQueueScript());
+  writeFile(path.join(destinationRoot, ".agentic-dev/runtime/dispatch_agents.mjs"), dispatchQueueScript());
   writeFile(path.join(destinationRoot, ".agentic-dev/runtime/close_completed_tasks.mjs"), closeTasksScript());
+  writeFile(path.join(destinationRoot, ".agentic-dev/runtime/server.mjs"), serverScript());
 }
 
 export function buildOrchestrationConfig(setupSelections = {}) {
@@ -235,7 +413,10 @@ export function buildOrchestrationConfig(setupSelections = {}) {
     workflow: {
       ir_output: ".agentic-dev/generated/task-ir.json",
       queue_output: ".agentic-dev/generated/agent-queue.json",
+      dispatch_output: ".agentic-dev/generated/dispatch-plan.json",
       workflow_file: ".github/workflows/agentic-orchestration.yml",
+      server_entry: ".agentic-dev/runtime/server.mjs",
+      server_port: 4310,
     },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-dev",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "GitHub Project based installer and multi-agent orchestration CLI for public say828/template-* repos.",
   "type": "module",
   "packageManager": "pnpm@10.32.0",