agentic-dev 0.2.12 → 0.2.14

package/lib/orchestration-assets.mjs

@@ -0,0 +1,430 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const SPECIALIZED_AGENTS = [
+  { id: "architecture", description: "Drive boundaries, system shape, and migration decisions." },
+  { id: "specs", description: "Translate SDD planning artifacts into actionable task structure." },
+  { id: "runtime", description: "Own application/runtime implementation work." },
+  { id: "ui", description: "Own screen and UI delivery tasks." },
+  { id: "api", description: "Own contract and API work." },
+  { id: "quality", description: "Run verification and regression closure." },
+  { id: "gitops", description: "Own GitHub Projects, workflow automation, and delivery closure." },
+];
+
+function repoRootDir() {
+  return path.resolve(new URL("..", import.meta.url).pathname);
+}
+
+function copyRecursive(sourceRoot, destinationRoot) {
+  fs.mkdirSync(destinationRoot, { recursive: true });
+  for (const entry of fs.readdirSync(sourceRoot, { withFileTypes: true })) {
+    const sourcePath = path.join(sourceRoot, entry.name);
+    const destinationPath = path.join(destinationRoot, entry.name);
+    if (entry.isDirectory()) {
+      copyRecursive(sourcePath, destinationPath);
+    } else {
+      fs.copyFileSync(sourcePath, destinationPath);
+    }
+  }
+}
+
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+function workflowYaml() {
+  return `name: Agentic Orchestration
+
+on:
+  push:
+    paths:
+      - "sdd/02_plan/**"
+      - ".agentic-dev/orchestration.json"
+      - ".agentic-dev/runtime/**"
+  workflow_dispatch:
+
+jobs:
+  orchestrate:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+      repository-projects: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        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: curl -fsS -X POST http://127.0.0.1:4310/sync/ir
+
+      - name: Sync GitHub project tasks
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        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: 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: 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: [] });
+}
+`;
+}
+
+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 [];
+  const files = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) files.push(...walk(full));
+    else if (entry.name.endsWith(".md")) files.push(full);
+  }
+  return files;
+}
+
+function parseChecklist(markdown, source) {
+  const tasks = [];
+  const lines = markdown.split(/\\r?\\n/);
+  for (const [index, line] of lines.entries()) {
+    const match = line.match(/^- \\[( |x)\\] (.+)$/);
+    if (!match) continue;
+    const status = match[1] === "x" ? "closed" : "open";
+    const title = match[2].trim();
+    const id = \`\${path.basename(source, ".md")}:\${index + 1}\`;
+    tasks.push({ id, title, status, source });
+  }
+  return tasks;
+}
+
+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 outputPath = generatedPath("task-ir.json");
+writeJson(outputPath, { generated_at: new Date().toISOString(), tasks });
+console.log(\`task_ir=\${outputPath}\`);
+console.log(\`tasks=\${tasks.length}\`);
+`;
+}
+
+function syncProjectTasksScript() {
+  return `#!/usr/bin/env node
+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") {
+    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 { generatedPath, loadTaskIr, orchestrationConfig, writeJson } from "./runtime-lib.mjs";
+
+const orchestration = orchestrationConfig();
+const taskIr = loadTaskIr();
+
+function classifyAgent(title) {
+  const lower = title.toLowerCase();
+  if (lower.includes("api") || lower.includes("contract")) return "api";
+  if (lower.includes("screen") || lower.includes("ui")) return "ui";
+  if (lower.includes("verify") || lower.includes("test") || lower.includes("proof")) return "quality";
+  if (lower.includes("workflow") || lower.includes("project") || lower.includes("github")) return "gitops";
+  if (lower.includes("arch") || lower.includes("boundary") || lower.includes("structure")) return "architecture";
+  return "runtime";
+}
+
+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 = generatedPath("agent-queue.json");
+writeJson(outputPath, { providers: orchestration.providers, queue });
+console.log(\`agent_queue=\${outputPath}\`);
+console.log(\`queued=\${queue.length}\`);
+`;
+}
+
+function dispatchQueueScript() {
+  return `#!/usr/bin/env node
+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 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 = 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;
+  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"));
+  copyRecursive(path.join(root, ".claude"), path.join(destinationRoot, ".claude"));
+  copyRecursive(path.join(root, ".codex"), path.join(destinationRoot, ".codex"));
+}
+
+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 = {}) {
+  return {
+    project_name: setupSelections.projectName || "",
+    specialized_agents: SPECIALIZED_AGENTS,
+    providers: Array.isArray(setupSelections.providerProfiles) ? setupSelections.providerProfiles : [],
+    github: {
+      repository: setupSelections.githubRepository || {},
+      project: setupSelections.githubProject || {},
+      project_mode: setupSelections.githubProjectMode || "create-if-missing",
+    },
+    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,
+    },
+  };
+}
+
+export function writeOrchestrationConfig(destinationRoot, setupSelections = {}) {
+  const config = buildOrchestrationConfig(setupSelections);
+  writeFile(
+    path.join(destinationRoot, ".agentic-dev/orchestration.json"),
+    `${JSON.stringify(config, null, 2)}\n`,
+  );
+}

package/lib/scaffold.mjs

@@ -3,6 +3,12 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { spawnSync } from "node:child_process";
+import { ensureGitHubProject, ensureGitHubRepository } from "./github.mjs";
+import {
+  installOrchestrationAssets,
+  installSharedAgentAssets,
+  writeOrchestrationConfig,
+} from "./orchestration-assets.mjs";
 
 export const DEFAULT_TEMPLATE_OWNER = "say828";
 
@@ -64,6 +70,10 @@ export function parseArgs(argv) {
     owner: DEFAULT_TEMPLATE_OWNER,
     appMode: "",
     aiProviders: [],
+    providerProfiles: [],
+    githubRepositoryInput: "",
+    githubProjectMode: "",
+    githubProjectTitle: "",
     githubAuthMode: "",
     githubPat: "",
     force: false,
@@ -100,6 +110,23 @@ export function parseArgs(argv) {
           .filter(Boolean);
         break;
       }
+      case "--provider-profiles": {
+        const value = args.shift() ?? "";
+        options.providerProfiles = value
+          .split(",")
+          .map((entry) => entry.trim())
+          .filter(Boolean);
+        break;
+      }
+      case "--github-repo":
+        options.githubRepositoryInput = args.shift() ?? "";
+        break;
+      case "--github-project-mode":
+        options.githubProjectMode = args.shift() ?? "";
+        break;
+      case "--github-project-title":
+        options.githubProjectTitle = args.shift() ?? "";
+        break;
       case "--github-auth":
         options.githubAuthMode = args.shift() ?? "";
         break;
@@ -143,6 +170,7 @@ export function usage() {
     "  npx agentic-dev init my-app",
     "  npx agentic-dev init my-app --template template-web --yes",
     "  npx agentic-dev init my-app --template template-web --project-name my-app --providers codex,claude",
+    "  npx agentic-dev init my-app --github-repo say828/my-app --github-project-title 'My App Delivery' --provider-profiles codex-subscription,openai-api",
     "",
     "Options:",
     "  --template, -t     Template repo name or suffix to use",
@@ -150,6 +178,10 @@ export function usage() {
     "  --owner            GitHub owner for template-* repos (default: say828)",
     "  --app-mode         App mode: fullstack, frontend, backend",
     "  --providers        Comma-separated AI providers: codex, claude, ollama",
+    "  --provider-profiles Provider/runtime list such as codex-subscription, claude-api, openai-api",
+    "  --github-repo      GitHub repo slug or URL to create/use",
+    "  --github-project-mode create-if-missing or use-existing",
+    "  --github-project-title GitHub Project title to bind orchestration to",
     "  --github-auth      GitHub auth mode: public, env, pat",
     "  --github-pat       GitHub PAT for this run only",
     "  --force            Allow scaffolding into a non-empty directory",
@@ -174,6 +206,33 @@ export function ensureTargetDir(targetDir, { force = false } = {}) {
   return resolved;
 }
 
+function initializeGitRepository(destinationRoot, githubRepository) {
+  const gitDir = path.join(destinationRoot, ".git");
+  if (!fs.existsSync(gitDir)) {
+    runCommand("git", ["init", "-b", "main"], {
+      cwd: destinationRoot,
+      label: "Initializing git repository",
+    });
+  }
+
+  const remotes = spawnSync("git", ["remote"], {
+    cwd: destinationRoot,
+    encoding: "utf-8",
+  });
+  const existingRemotes = new Set((remotes.stdout || "").split(/\r?\n/).filter(Boolean));
+  if (existingRemotes.has("origin")) {
+    runCommand("git", ["remote", "set-url", "origin", githubRepository.cloneUrl], {
+      cwd: destinationRoot,
+      label: "Updating origin remote",
+    });
+  } else {
+    runCommand("git", ["remote", "add", "origin", githubRepository.cloneUrl], {
+      cwd: destinationRoot,
+      label: "Adding origin remote",
+    });
+  }
+}
+
 export async function fetchTemplateRepos({ owner = DEFAULT_TEMPLATE_OWNER } = {}) {
   const repos = [];
   let page = 1;
@@ -383,7 +442,12 @@ function writeSetupConfig(destinationRoot, setupSelections = {}) {
     template_owner: setupSelections.owner || DEFAULT_TEMPLATE_OWNER,
     app_mode: setupSelections.appMode || "fullstack",
     ai_providers: Array.isArray(setupSelections.aiProviders) ? setupSelections.aiProviders : [],
+    provider_profiles: Array.isArray(setupSelections.providerProfiles)
+      ? setupSelections.providerProfiles
+      : [],
     github_auth_mode: setupSelections.githubAuthMode || "public",
+    github_repository: setupSelections.githubRepository || null,
+    github_project: setupSelections.githubProject || null,
     github_pat_supplied: Boolean(setupSelections.githubPat),
     skip_bootstrap: Boolean(setupSelections.skipBootstrap),
   };
@@ -492,8 +556,11 @@ export function installTemplateRepo({
   skipBootstrap = false,
 }) {
   scaffoldFromTemplateRepo({ destinationRoot, templateRepo });
+  installSharedAgentAssets(destinationRoot);
+  installOrchestrationAssets(destinationRoot);
   applyProviderSelections(destinationRoot, setupSelections.aiProviders);
   applyProjectMetadata(destinationRoot, setupSelections);
+  writeOrchestrationConfig(destinationRoot, setupSelections);
   writeSetupConfig(destinationRoot, {
     ...setupSelections,
     templateRepo: templateRepo.name,
@@ -518,3 +585,25 @@ export function installTemplateRepo({
     nextSteps: effectiveSkipBootstrap ? [bootstrapHint] : [],
   };
 }
+
+export async function resolveGitHubOrchestration(setupSelections = {}) {
+  const repository = await ensureGitHubRepository(
+    setupSelections.githubRepositoryInput || setupSelections.projectName,
+  );
+  const project = await ensureGitHubProject({
+    ownerLogin: repository.owner,
+    title: setupSelections.githubProjectTitle || `${setupSelections.projectName} Delivery`,
+    mode: setupSelections.githubProjectMode || "create-if-missing",
+  });
+
+  return {
+    githubRepository: repository,
+    githubProject: project,
+  };
+}
+
+export function finalizeRepositoryGit(destinationRoot, setupSelections = {}) {
+  if (setupSelections.githubRepository) {
+    initializeGitRepository(destinationRoot, setupSelections.githubRepository);
+  }
+}

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "agentic-dev",
-  "version": "0.2.12",
-  "description": "GitHub-based installer CLI for public say828/template-* repos.",
+  "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",
   "bin": {
     "agentic-dev": "./bin/agentic-dev.mjs"
   },
   "files": [
+    ".agent",
+    ".claude",
+    ".codex",
     "bin",
     "lib",
     "README.md"