agentic-dev 0.2.14 → 0.2.16

package/lib/github.mjs

@@ -1,246 +0,0 @@
-import process from "node:process";
-import { spawnSync } from "node:child_process";
-
-function ghToken() {
-  const envToken =
-    process.env.GH_TOKEN || process.env.GITHUB_TOKEN || process.env.AGENTIC_GITHUB_TOKEN || "";
-  if (envToken) {
-    return envToken;
-  }
-
-  const result = spawnSync("gh", ["auth", "token"], {
-    encoding: "utf-8",
-    stdio: ["ignore", "pipe", "ignore"],
-  });
-  if (result.status === 0) {
-    return (result.stdout || "").trim();
-  }
-  return "";
-}
-
-async function githubRequest(url, { method = "GET", body } = {}) {
-  const token = ghToken();
-  if (!token) {
-    throw new Error("GitHub authentication is required. Set GH_TOKEN, GITHUB_TOKEN, or AGENTIC_GITHUB_TOKEN.");
-  }
-
-  const response = await fetch(url, {
-    method,
-    headers: {
-      Accept: "application/vnd.github+json",
-      "Content-Type": "application/json",
-      "User-Agent": "agentic-dev",
-      Authorization: `Bearer ${token}`,
-    },
-    body: body ? JSON.stringify(body) : undefined,
-  });
-
-  if (!response.ok) {
-    const payload = await response.text();
-    throw new Error(`GitHub API request failed (${response.status}): ${payload}`);
-  }
-
-  if (response.status === 204) {
-    return null;
-  }
-  return response.json();
-}
-
-async function githubGraphql(query, variables = {}) {
-  const token = ghToken();
-  if (!token) {
-    throw new Error("GitHub authentication is required. Set GH_TOKEN, GITHUB_TOKEN, or AGENTIC_GITHUB_TOKEN.");
-  }
-
-  const response = await fetch("https://api.github.com/graphql", {
-    method: "POST",
-    headers: {
-      Accept: "application/vnd.github+json",
-      "Content-Type": "application/json",
-      "User-Agent": "agentic-dev",
-      Authorization: `Bearer ${token}`,
-    },
-    body: JSON.stringify({ query, variables }),
-  });
-
-  const payload = await response.json();
-  if (!response.ok || payload.errors) {
-    throw new Error(`GitHub GraphQL request failed: ${JSON.stringify(payload.errors || payload)}`);
-  }
-  return payload.data;
-}
-
-export function normalizeRepoInput(input, { fallbackOwner = "say828", fallbackName = "agentic-service" } = {}) {
-  const normalized = (input || "").trim();
-  if (!normalized) {
-    return {
-      owner: fallbackOwner,
-      name: fallbackName,
-      slug: `${fallbackOwner}/${fallbackName}`,
-      cloneUrl: `https://github.com/${fallbackOwner}/${fallbackName}.git`,
-      htmlUrl: `https://github.com/${fallbackOwner}/${fallbackName}`,
-    };
-  }
-
-  const withoutGit = normalized.replace(/\.git$/, "");
-  const httpsMatch = withoutGit.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)$/);
-  if (httpsMatch) {
-    const [, owner, name] = httpsMatch;
-    return {
-      owner,
-      name,
-      slug: `${owner}/${name}`,
-      cloneUrl: `https://github.com/${owner}/${name}.git`,
-      htmlUrl: `https://github.com/${owner}/${name}`,
-    };
-  }
-
-  const slugMatch = withoutGit.match(/^([^/]+)\/([^/]+)$/);
-  if (slugMatch) {
-    const [, owner, name] = slugMatch;
-    return {
-      owner,
-      name,
-      slug: `${owner}/${name}`,
-      cloneUrl: `https://github.com/${owner}/${name}.git`,
-      htmlUrl: `https://github.com/${owner}/${name}`,
-    };
-  }
-
-  return {
-    owner: fallbackOwner,
-    name: withoutGit,
-    slug: `${fallbackOwner}/${withoutGit}`,
-    cloneUrl: `https://github.com/${fallbackOwner}/${withoutGit}.git`,
-    htmlUrl: `https://github.com/${fallbackOwner}/${withoutGit}`,
-  };
-}
-
-export async function getAuthenticatedViewer() {
-  const data = await githubGraphql(`
-    query ViewerIdentity {
-      viewer {
-        login
-        id
-      }
-    }
-  `);
-  return data.viewer;
-}
-
-export async function ensureGitHubRepository(repoInput, { visibility = "private" } = {}) {
-  const viewer = await getAuthenticatedViewer();
-  const target = normalizeRepoInput(repoInput, {
-    fallbackOwner: viewer.login,
-  });
-
-  try {
-    const existing = await githubRequest(`https://api.github.com/repos/${target.owner}/${target.name}`);
-    return {
-      owner: existing.owner.login,
-      name: existing.name,
-      slug: existing.full_name,
-      cloneUrl: existing.clone_url,
-      htmlUrl: existing.html_url,
-      created: false,
-    };
-  } catch (error) {
-    const message = String(error.message || error);
-    if (!message.includes("(404)")) {
-      throw error;
-    }
-  }
-
-  if (target.owner !== viewer.login) {
-    throw new Error(
-      `Repository ${target.slug} does not exist. Automatic creation currently supports only the authenticated user namespace (${viewer.login}).`,
-    );
-  }
-
-  const created = await githubRequest("https://api.github.com/user/repos", {
-    method: "POST",
-    body: {
-      name: target.name,
-      private: visibility !== "public",
-      auto_init: false,
-    },
-  });
-
-  return {
-    owner: created.owner.login,
-    name: created.name,
-    slug: created.full_name,
-    cloneUrl: created.clone_url,
-    htmlUrl: created.html_url,
-    created: true,
-  };
-}
-
-export async function ensureGitHubProject({ ownerLogin, title, mode = "create-if-missing" }) {
-  const data = await githubGraphql(
-    `
-      query OwnerProjects($login: String!) {
-        user(login: $login) {
-          id
-          projectsV2(first: 50) {
-            nodes {
-              id
-              title
-              number
-              url
-            }
-          }
-        }
-      }
-    `,
-    { login: ownerLogin },
-  );
-
-  const owner = data.user;
-  if (!owner) {
-    throw new Error(`Unable to load GitHub projects for ${ownerLogin}.`);
-  }
-
-  const existing = owner.projectsV2.nodes.find((project) => project.title === title);
-  if (existing) {
-    return {
-      id: existing.id,
-      title: existing.title,
-      number: existing.number,
-      url: existing.url,
-      created: false,
-    };
-  }
-
-  if (mode !== "create-if-missing") {
-    throw new Error(`GitHub project not found: ${title}`);
-  }
-
-  const created = await githubGraphql(
-    `
-      mutation CreateProject($ownerId: ID!, $title: String!) {
-        createProjectV2(input: { ownerId: $ownerId, title: $title }) {
-          projectV2 {
-            id
-            title
-            number
-            url
-          }
-        }
-      }
-    `,
-    {
-      ownerId: owner.id,
-      title,
-    },
-  );
-
-  const project = created.createProjectV2.projectV2;
-  return {
-    id: project.id,
-    title: project.title,
-    number: project.number,
-    url: project.url,
-    created: true,
-  };
-}

package/lib/orchestration-assets.mjs

@@ -1,430 +0,0 @@
-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`,
-  );
-}