agentic-dev 0.2.11 → 0.2.13

package/lib/github.mjs

@@ -0,0 +1,246 @@
+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

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

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,7 +1,7 @@
 {
   "name": "agentic-dev",
-  "version": "0.2.11",
-  "description": "Scaffold a public say828/template-* repo and run install/bootstrap automatically.",
+  "version": "0.2.13",
+  "description": "GitHub Project based installer and multi-agent orchestration CLI for public say828/template-* repos.",
   "type": "module",
   "packageManager": "pnpm@10.32.0",
   "bin": {
@@ -12,30 +12,19 @@
     ".claude",
     ".codex",
     "bin",
-    "client",
-    "infra",
     "lib",
-    "scripts",
-    "sdd",
-    "server",
-    ".dockerignore",
-    ".env.example",
-    ".gitignore",
-    "AGENTS.md",
-    "README.md",
-    "SDD_SKILL.md",
-    "compose.yml",
-    "pnpm-workspace.yaml"
+    "README.md"
   ],
   "scripts": {
-    "smoke:init": "node ./bin/agentic-dev.mjs init ./.tmp-agentic-smoke --template template-fullstack-mono --yes --force"
+    "smoke:init": "node ./bin/agentic-dev.mjs init ./.tmp-agentic-smoke --template template-web --app-mode backend --providers codex --yes --force"
   },
   "keywords": [
     "agentic",
-    "template",
     "scaffold",
-    "vite",
-    "react"
+    "cli",
+    "github",
+    "template",
+    "orchestration"
   ],
   "license": "UNLICENSED"
 }

package/.dockerignore

@@ -1,8 +0,0 @@
-.git
-node_modules
-**/node_modules
-**/dist
-**/.venv
-**/__pycache__
-**/.pytest_cache
-**/*.tsbuildinfo