agentic-dev 0.2.12 → 0.2.13

package/bin/agentic-dev.mjs

@@ -8,15 +8,18 @@ import {
   DEFAULT_TEMPLATE_OWNER,
   ensureTargetDir,
   fetchTemplateRepos,
+  finalizeRepositoryGit,
   installTemplateRepo,
   parseArgs,
   resolveTemplateRepo,
+  resolveGitHubOrchestration,
   usage,
 } from "../lib/scaffold.mjs";
 
 const DEFAULT_TARGET_DIR = ".";
 const DEFAULT_APP_MODE = "fullstack";
 const DEFAULT_AI_PROVIDERS = ["codex", "claude"];
+const DEFAULT_PROVIDER_PROFILES = ["codex-subscription", "claude-subscription"];
 
 const GITHUB_AUTH_CHOICES = [
   {
@@ -72,6 +75,28 @@ const AI_PROVIDER_CHOICES = [
   },
 ];
 
+const PROVIDER_PROFILE_CHOICES = [
+  { label: "codex-subscription", value: "codex-subscription", description: "Codex subscription/runtime access" },
+  { label: "codex-api", value: "codex-api", description: "Codex API access" },
+  { label: "claude-subscription", value: "claude-subscription", description: "Claude subscription/runtime access" },
+  { label: "claude-api", value: "claude-api", description: "Claude API access" },
+  { label: "openai-api", value: "openai-api", description: "OpenAI API access" },
+  { label: "ollama-self-hosted", value: "ollama-self-hosted", description: "Local Ollama runtime" },
+];
+
+const GITHUB_PROJECT_MODE_CHOICES = [
+  {
+    label: "create-if-missing",
+    value: "create-if-missing",
+    description: "Use an existing GitHub Project with the same title, otherwise create it",
+  },
+  {
+    label: "use-existing",
+    value: "use-existing",
+    description: "Require an existing GitHub Project and fail if it does not exist",
+  },
+];
+
 const CONFIRM_CHOICES = [
   {
     label: "Proceed",
@@ -128,6 +153,16 @@ function uniqueProviders(providers) {
     : [];
 }
 
+function normalizeProviderProfiles(providerProfiles) {
+  const normalized = Array.isArray(providerProfiles)
+    ? providerProfiles.map((profile) => profile.trim()).filter(Boolean)
+    : [];
+  if (normalized.length > 0) {
+    return [...new Set(normalized)];
+  }
+  return [...DEFAULT_PROVIDER_PROFILES];
+}
+
 function hydrateOptions(options) {
   const state = {
     targetDir: (options.targetDir || DEFAULT_TARGET_DIR).trim() || DEFAULT_TARGET_DIR,
@@ -137,6 +172,10 @@ function hydrateOptions(options) {
     githubPat: options.githubPat || "",
     appMode: (options.appMode || DEFAULT_APP_MODE).trim() || DEFAULT_APP_MODE,
     aiProviders: normalizeProviders(options.aiProviders),
+    providerProfiles: normalizeProviderProfiles(options.providerProfiles),
+    githubRepositoryInput: (options.githubRepositoryInput || "").trim(),
+    githubProjectMode: (options.githubProjectMode || "create-if-missing").trim() || "create-if-missing",
+    githubProjectTitle: (options.githubProjectTitle || "").trim(),
     force: Boolean(options.force),
     skipBootstrap: Boolean(options.skipBootstrap),
     owner: options.owner || DEFAULT_TEMPLATE_OWNER,
@@ -145,6 +184,12 @@ function hydrateOptions(options) {
   if (!state.projectName) {
     state.projectName = inferProjectName(state.targetDir);
   }
+  if (!state.githubRepositoryInput) {
+    state.githubRepositoryInput = state.projectName;
+  }
+  if (!state.githubProjectTitle) {
+    state.githubProjectTitle = `${state.projectName} Delivery`;
+  }
 
   return state;
 }
@@ -166,6 +211,7 @@ function sanitizeStateForInstall(state) {
     targetDir: (state.targetDir || DEFAULT_TARGET_DIR).trim() || DEFAULT_TARGET_DIR,
     projectName: (state.projectName || inferProjectName(state.targetDir)).trim(),
     aiProviders: normalizeProviders(state.aiProviders),
+    providerProfiles: normalizeProviderProfiles(state.providerProfiles),
   };
 }
 
@@ -193,6 +239,13 @@ function buildSteps(state, repos) {
       description: "Written into scaffold metadata and Claude workspace nickname.",
       placeholder: inferProjectName(state.targetDir),
     },
+    {
+      key: "githubRepositoryInput",
+      type: "text",
+      label: "GitHub repository",
+      description: "Use owner/name, a GitHub URL, or just a repo name to create/use the repository.",
+      placeholder: state.projectName,
+    },
     {
       key: "githubAuthMode",
       type: "single",
@@ -213,6 +266,20 @@ function buildSteps(state, repos) {
   }
 
   steps.push(
+    {
+      key: "githubProjectMode",
+      type: "single",
+      label: "GitHub project mode",
+      description: "Choose whether the orchestration must reuse an existing GitHub Project or create one if needed.",
+      choices: GITHUB_PROJECT_MODE_CHOICES,
+    },
+    {
+      key: "githubProjectTitle",
+      type: "text",
+      label: "GitHub project title",
+      description: "This project is used for SDD task orchestration.",
+      placeholder: `${state.projectName} Delivery`,
+    },
     {
       key: "template",
       type: "single",
@@ -227,11 +294,18 @@ function buildSteps(state, repos) {
       description: "Choose how much of the bootstrap flow should run after clone.",
       choices: APP_MODE_CHOICES,
     },
+    {
+      key: "providerProfiles",
+      type: "multi",
+      label: "AI runtime profiles",
+      description: "Use Space to toggle provider/runtime profiles.",
+      choices: PROVIDER_PROFILE_CHOICES,
+    },
     {
       key: "aiProviders",
       type: "multi",
-      label: "AI providers",
-      description: "Use Space to toggle. At least one provider must stay selected.",
+      label: "Workspace agent surfaces",
+      description: "Use Space to toggle Codex/Claude workspace assets.",
       choices: AI_PROVIDER_CHOICES,
     },
   );
@@ -275,6 +349,12 @@ function stepValue(state, step) {
   if (step.key === "projectName") {
     return state.projectName || step.placeholder || inferProjectName(state.targetDir);
   }
+  if (step.key === "githubRepositoryInput") {
+    return state.githubRepositoryInput || step.placeholder || state.projectName;
+  }
+  if (step.key === "githubProjectTitle") {
+    return state.githubProjectTitle || step.placeholder || `${state.projectName} Delivery`;
+  }
   if (step.key === "githubPat") {
     return state.githubPat || "";
   }
@@ -356,10 +436,14 @@ function executionPreview(state, selectedRepo) {
   const lines = [
     `Project directory: ${path.resolve(process.cwd(), state.targetDir)}`,
     `Project name: ${state.projectName}`,
+    `GitHub repository: ${state.githubRepositoryInput}`,
+    `GitHub project mode: ${state.githubProjectMode}`,
+    `GitHub project title: ${state.githubProjectTitle}`,
     `GitHub auth mode: ${state.githubAuthMode}`,
     `Template repo: ${selectedRepo?.name || state.template}`,
     `App mode: ${state.appMode}`,
     `AI providers: ${state.aiProviders.join(", ")}`,
+    `Provider profiles: ${state.providerProfiles.join(", ")}`,
     `Allow non-empty directory: ${state.force ? "yes" : "no"}`,
   ];
 
@@ -368,14 +452,17 @@ function executionPreview(state, selectedRepo) {
   }
 
   lines.push("Run plan:");
-  lines.push(`  1. Clone ${selectedRepo?.name || state.template}`);
-  lines.push("  2. Copy .env.example to .env if needed");
-  lines.push("  3. Run pnpm install");
+  lines.push(`  1. Ensure GitHub repo ${state.githubRepositoryInput}`);
+  lines.push(`  2. Ensure GitHub Project ${state.githubProjectTitle}`);
+  lines.push(`  3. Clone ${selectedRepo?.name || state.template}`);
+  lines.push("  4. Install shared sub-agent assets and orchestration workflow");
+  lines.push("  5. Copy .env.example to .env if needed");
+  lines.push("  6. Run pnpm install");
   if (state.appMode === "backend") {
-    lines.push("  4. Skip browser install and parity bootstrap");
+    lines.push("  7. Skip browser install and parity bootstrap");
   } else {
-    lines.push("  4. Install Playwright Chromium for the default frontend target");
-    lines.push("  5. Run frontend parity bootstrap");
+    lines.push("  7. Install Playwright Chromium for the default frontend target");
+    lines.push("  8. Run frontend parity bootstrap");
   }
 
   return lines;
@@ -464,6 +551,22 @@ function validateStepValue(step, state, value) {
     return trimmed;
   }
 
+  if (step.key === "githubRepositoryInput") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new Error("GitHub repository cannot be empty.");
+    }
+    return trimmed;
+  }
+
+  if (step.key === "githubProjectTitle") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new Error("GitHub project title cannot be empty.");
+    }
+    return trimmed;
+  }
+
   if (step.key === "githubPat") {
     const trimmed = value.trim();
     if (!trimmed) {
@@ -480,6 +583,14 @@ function validateStepValue(step, state, value) {
     return providers;
   }
 
+  if (step.key === "providerProfiles") {
+    const profiles = normalizeProviderProfiles(value);
+    if (profiles.length === 0) {
+      throw new Error("Select at least one provider profile.");
+    }
+    return profiles;
+  }
+
   if (step.key === "force" && value === false) {
     throw new Error("Prompt cancelled");
   }
@@ -603,14 +714,22 @@ async function runWizard(initialState, repos) {
       }
 
       if (step.type === "multi" && chunk === " ") {
-        const selected = new Set(uniqueProviders(state.aiProviders));
+        const selected = new Set(
+          step.key === "providerProfiles"
+            ? normalizeProviderProfiles(state.providerProfiles)
+            : uniqueProviders(state.aiProviders),
+        );
         const currentChoice = step.choices[cursors.get(step.key)];
         if (selected.has(currentChoice.value)) {
           selected.delete(currentChoice.value);
         } else {
           selected.add(currentChoice.value);
         }
-        state.aiProviders = [...selected];
+        if (step.key === "providerProfiles") {
+          state.providerProfiles = [...selected];
+        } else {
+          state.aiProviders = [...selected];
+        }
         rerender();
         return undefined;
       }
@@ -698,6 +817,10 @@ async function promptForMultiChoice(rl, label, choices, defaults) {
   }
 }
 
+async function promptMultiProfiles(rl, label, choices, defaults) {
+  return promptForMultiChoice(rl, label, choices, defaults);
+}
+
 function printFallbackPlan(state, repos) {
   const selectedRepo = resolveTemplateRepo(state.template, repos);
   console.log("");
@@ -719,6 +842,9 @@ async function promptLinearly(initialState, repos) {
     const projectNameAnswer = await rl.question(`Project name [${state.projectName || defaultProjectName}]: `);
     state.projectName = projectNameAnswer.trim() || state.projectName || defaultProjectName;
 
+    const repoAnswer = await rl.question(`GitHub repository [${state.githubRepositoryInput || state.projectName}]: `);
+    state.githubRepositoryInput = repoAnswer.trim() || state.githubRepositoryInput || state.projectName;
+
     state.githubAuthMode = await promptForChoice(rl, "GitHub auth mode", GITHUB_AUTH_CHOICES);
     if (state.githubAuthMode === "pat") {
       state.githubPat = (await rl.question("GitHub PAT: ")).trim();
@@ -727,8 +853,19 @@ async function promptLinearly(initialState, repos) {
       }
     }
 
+    state.githubProjectMode = await promptForChoice(rl, "GitHub project mode", GITHUB_PROJECT_MODE_CHOICES);
+    const projectTitleAnswer = await rl.question(`GitHub project title [${state.githubProjectTitle || `${state.projectName} Delivery`}]: `);
+    state.githubProjectTitle =
+      projectTitleAnswer.trim() || state.githubProjectTitle || `${state.projectName} Delivery`;
+
     state.template = await promptForChoice(rl, `Template repo from ${state.owner}`, buildTemplateChoices(repos));
     state.appMode = await promptForChoice(rl, "App mode", APP_MODE_CHOICES);
+    state.providerProfiles = await promptMultiProfiles(
+      rl,
+      "AI runtime profiles",
+      PROVIDER_PROFILE_CHOICES,
+      state.providerProfiles,
+    );
     state.aiProviders = await promptForMultiChoice(rl, "AI providers", AI_PROVIDER_CHOICES, state.aiProviders);
 
     if (!state.force && directoryHasUserFiles(state.targetDir)) {
@@ -789,6 +926,12 @@ function validateNonInteractiveState(state) {
   if (!state.projectName) {
     state.projectName = inferProjectName(state.targetDir);
   }
+  if (!state.githubRepositoryInput) {
+    state.githubRepositoryInput = state.projectName;
+  }
+  if (!state.githubProjectTitle) {
+    state.githubProjectTitle = `${state.projectName} Delivery`;
+  }
   if (state.githubAuthMode === "pat" && !state.githubPat) {
     throw new Error("`--github-auth pat` requires `--github-pat`.");
   }
@@ -843,6 +986,7 @@ async function main() {
         : await promptLinearly(state, repos);
 
     applyRuntimeGitHubAuth(resolvedState);
+    const orchestration = await resolveGitHubOrchestration(resolvedState);
     const selectedRepo = resolveTemplateRepo(resolvedState.template, repos);
     const destinationRoot = ensureTargetDir(resolvedState.targetDir, {
       force: resolvedState.force,
@@ -850,9 +994,16 @@ async function main() {
     const result = installTemplateRepo({
       destinationRoot: path.resolve(destinationRoot),
       templateRepo: selectedRepo,
-      setupSelections: resolvedState,
+      setupSelections: {
+        ...resolvedState,
+        ...orchestration,
+      },
       skipBootstrap: resolvedState.skipBootstrap,
     });
+    finalizeRepositoryGit(path.resolve(destinationRoot), {
+      ...resolvedState,
+      ...orchestration,
+    });
     printSuccess(result);
   } catch (error) {
     console.error(error.message);

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,
+  };
+}