agentic-dev 0.2.13 → 0.2.15

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,249 +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: Build task IR from SDD planning
-        run: node .agentic-dev/runtime/sdd_to_ir.mjs
-
-      - name: Sync GitHub project tasks
-        env:
-          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
-        run: node .agentic-dev/runtime/sync_project_tasks.mjs
-
-      - name: Plan multi-agent queue
-        env:
-          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
-        run: node .agentic-dev/runtime/run_multi_agent_queue.mjs
-
-      - name: Close completed tasks
-        env:
-          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
-        run: node .agentic-dev/runtime/close_completed_tasks.mjs
-`;
-}
-
-function sddToIrScript() {
-  return `#!/usr/bin/env node
-import fs from "node:fs";
-import path from "node:path";
-
-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 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");
-console.log(\`task_ir=\${outputPath}\`);
-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();
-}
-
-const existingIssues = ghJson(["issue", "list", "--repo", orchestration.github.repository.slug, "--state", "all", "--limit", "200", "--json", "number,title,state"]);
-
-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"]);
-  }
-  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."]);
-  }
-}
-
-console.log(\`synced_tasks=\${taskIr.tasks.length}\`);
-`;
-}
-
-function runQueueScript() {
-  return `#!/usr/bin/env node
-import fs from "node:fs";
-
-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 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),
-}));
-
-const outputPath = ".agentic-dev/generated/agent-queue.json";
-fs.writeFileSync(outputPath, JSON.stringify({ providers: orchestration.providers, queue }, null, 2) + "\\n");
-console.log(\`agent_queue=\${outputPath}\`);
-console.log(\`queued=\${queue.length}\`);
-`;
-}
-
-function closeTasksScript() {
-  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"));
-
-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" }));
-
-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" });
-}
-
-console.log(\`closed_candidates=\${closedIds.size}\`);
-`;
-}
-
-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/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/close_completed_tasks.mjs"), closeTasksScript());
-}
-
-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",
-      workflow_file: ".github/workflows/agentic-orchestration.yml",
-    },
-  };
-}
-
-export function writeOrchestrationConfig(destinationRoot, setupSelections = {}) {
-  const config = buildOrchestrationConfig(setupSelections);
-  writeFile(
-    path.join(destinationRoot, ".agentic-dev/orchestration.json"),
-    `${JSON.stringify(config, null, 2)}\n`,
-  );
-}