agentic-dev 0.1.0 → 0.2.0

package/bin/agentic-dev.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-
-import { main } from "../src/cli.js";
-
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`agentic-dev: ${message}`);
-  process.exitCode = 1;
-});

package/src/cli.js

@@ -1,37 +0,0 @@
-import { runInit } from "./init-command.js";
-import { pathToFileURL } from "node:url";
-
-function printHelp() {
-  console.log(`agentic-dev
-
-Usage:
-  agentic-dev init
-
-Commands:
-  init    Materialize a new repo from agentic-core + a selected template repo.
-`);
-}
-
-export async function main(argv = process.argv.slice(2)) {
-  const [command] = argv;
-
-  if (!command || command === "-h" || command === "--help") {
-    printHelp();
-    return;
-  }
-
-  if (command === "init") {
-    await runInit();
-    return;
-  }
-
-  throw new Error(`unknown command: ${command}`);
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  main().catch((error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`agentic-dev: ${message}`);
-    process.exitCode = 1;
-  });
-}

package/src/init-command.js

@@ -1,230 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  assertGhCliAuthenticated,
-  createProject,
-  ensureGitHubRepositoryExists,
-  getProject,
-  getRepositoryMetadata,
-  listTemplateRepositories,
-} from "./lib/github.js";
-import {
-  assertEmptyRepoRoot,
-  copyDirectory,
-  ensureDirectory,
-  readJsonFile,
-  writeJsonFile,
-} from "./lib/fs.js";
-import { checkoutRepository, readGitCommit, readOriginRemote, validateGitRepoRoot } from "./lib/git.js";
-import { confirm, promptText, selectFromList } from "./lib/prompt.js";
-import {
-  buildArtifactContract,
-  buildInitAnswers,
-  buildLockFile,
-  loadTemplateContract,
-  renderTokensInDirectory,
-} from "./lib/template.js";
-import { runCommand } from "./lib/command.js";
-import { assertRequiredCommands } from "./lib/system.js";
-
-const DEFAULT_CORE_REPOSITORY = "do4ai/agentic-core";
-const PACKAGE_PATH = fileURLToPath(new URL("../package.json", import.meta.url));
-
-async function readInstallerVersion() {
-  const pkg = JSON.parse(await readFile(PACKAGE_PATH, "utf8"));
-  return pkg.version;
-}
-
-function formatRepositoryChoice(repository) {
-  const branch = repository.defaultBranch || "main";
-  return `${repository.nameWithOwner} (${branch})`;
-}
-
-async function chooseTemplate(org) {
-  const repositories = await listTemplateRepositories(org);
-  if (repositories.length === 0) {
-    throw new Error(`no template-* repositories found in ${org}`);
-  }
-
-  const index = await selectFromList(
-    "Select the template repository to compose into this repo:",
-    repositories.map((repository) => formatRepositoryChoice(repository)),
-  );
-  return repositories[index];
-}
-
-async function resolveRepositoryCoordinates(cwd) {
-  const remote = await readOriginRemote(cwd);
-  const remoteOwner = remote?.owner ?? "do4ai";
-  const remoteRepository = remote?.repo ?? path.basename(cwd);
-
-  const owner = await promptText("GitHub owner", remoteOwner);
-  const repository = await promptText("GitHub repository", remoteRepository);
-  await ensureGitHubRepositoryExists(`${owner}/${repository}`);
-  return { owner, repository };
-}
-
-async function resolveProject(owner, repository) {
-  const existingProjectNumber = await promptText(
-    "Existing GitHub Project number (leave blank to create a new project)",
-    "",
-  );
-
-  if (existingProjectNumber) {
-    const number = Number.parseInt(existingProjectNumber, 10);
-    if (!Number.isInteger(number) || number <= 0) {
-      throw new Error(`invalid project number: ${existingProjectNumber}`);
-    }
-    const project = await getProject(owner, number);
-    console.log(
-      `Warning: project ${owner}#${project.number} (${project.title}) already exists. ` +
-        "Continuing can create or update task items in that project.",
-    );
-    const proceed = await confirm("Continue with the existing project?", false);
-    if (!proceed) {
-      throw new Error("project bootstrap aborted by user");
-    }
-    return project;
-  }
-
-  const title = await promptText("New GitHub Project title", repository);
-  return createProject(owner, title);
-}
-
-async function bootstrapProjectContract({ cwd, coreCheckout, owner, repository, project }) {
-  const scriptPath = path.join(coreCheckout, "scripts/agentic-core/github_project_kit.py");
-  await runCommand("python3", [
-    scriptPath,
-    "bootstrap",
-    "--repo-root",
-    cwd,
-    "--owner",
-    owner,
-    "--project-number",
-    String(project.number),
-    "--repository",
-    `${owner}/${repository}`,
-    "--project-title",
-    project.title,
-    "--ensure-agent-role-field",
-    "--ensure-role-labels",
-  ]);
-}
-
-async function writeRepoBridgeFiles(cwd) {
-  await ensureDirectory(path.join(cwd, ".claude"));
-  await ensureDirectory(path.join(cwd, ".codex"));
-  await writeJsonFile(path.join(cwd, ".claude/agentic-dev.json"), {
-    contract_path: "../sdd/99_toolchain/01_automation/agentic-dev/repo-contract.json",
-  });
-  await writeJsonFile(path.join(cwd, ".codex/agentic-dev.json"), {
-    contract_path: "../sdd/99_toolchain/01_automation/agentic-dev/repo-contract.json",
-  });
-}
-
-async function writeInstallerLock({
-  cwd,
-  installerVersion,
-  coreRepository,
-  coreRef,
-  coreCheckout,
-  templateRepository,
-  templateRef,
-  templateCheckout,
-}) {
-  const payload = buildLockFile({
-    installerVersion,
-    coreRepository,
-    coreRef,
-    coreCommit: await readGitCommit(coreCheckout),
-    templateRepository,
-    templateRef,
-    templateCommit: await readGitCommit(templateCheckout),
-  });
-
-  await writeJsonFile(path.join(cwd, ".agentic-dev-lock.json"), payload);
-}
-
-export async function runInit() {
-  const cwd = process.cwd();
-  await assertRequiredCommands(["git", "gh", "python3"]);
-  await validateGitRepoRoot(cwd);
-  await assertEmptyRepoRoot(cwd);
-  await assertGhCliAuthenticated();
-
-  const installerVersion = await readInstallerVersion();
-
-  const coreRepository = await promptText("agentic-core repository", DEFAULT_CORE_REPOSITORY);
-  const coreMetadata = await getRepositoryMetadata(coreRepository);
-  const coreRef = await promptText("agentic-core ref", coreMetadata.defaultBranch);
-
-  const templateOrganization = await promptText("Template organization", "do4ai");
-  const templateRepository = await chooseTemplate(templateOrganization);
-  const templateRef = await promptText("Template ref", templateRepository.defaultBranch);
-
-  const { owner, repository } = await resolveRepositoryCoordinates(cwd);
-  const project = await resolveProject(owner, repository);
-  const answers = await buildInitAnswers({ owner, repository, projectTitle: project.title });
-
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "agentic-dev-"));
-  const coreCheckout = path.join(tempRoot, "agentic-core");
-  const templateCheckout = path.join(tempRoot, "template");
-
-  try {
-    console.log(`Fetching ${coreRepository}@${coreRef}`);
-    await checkoutRepository(coreRepository, coreRef, coreCheckout);
-
-    console.log(`Fetching ${templateRepository.nameWithOwner}@${templateRef}`);
-    await checkoutRepository(templateRepository.nameWithOwner, templateRef, templateCheckout);
-
-    console.log("Materializing template files");
-    await copyDirectory(templateCheckout, cwd);
-
-    const templateContract = await loadTemplateContract(templateCheckout);
-    console.log("Rendering template tokens");
-    await renderTokensInDirectory(cwd, answers.tokens, templateContract?.render_excludes ?? []);
-
-    console.log("Syncing agentic-core baseline");
-    await runCommand("python3", [
-      path.join(coreCheckout, "scripts/agentic-core/sync.py"),
-      "sync",
-      "--core-root",
-      coreCheckout,
-      "--source-root",
-      coreCheckout,
-      "--target-root",
-      cwd,
-    ]);
-
-    await writeRepoBridgeFiles(cwd);
-
-    console.log("Writing artifact contract");
-    const artifactContract = buildArtifactContract(templateContract);
-    await writeJsonFile(
-      path.join(cwd, "sdd/99_toolchain/01_automation/github-project-kit/artifact-contract.json"),
-      artifactContract,
-    );
-
-    console.log("Bootstrapping GitHub Project contract");
-    await bootstrapProjectContract({ cwd, coreCheckout, owner, repository, project });
-
-    console.log("Writing source lock manifest");
-    await writeInstallerLock({
-      cwd,
-      installerVersion,
-      coreRepository,
-      coreRef,
-      coreCheckout,
-      templateRepository: templateRepository.nameWithOwner,
-      templateRef,
-      templateCheckout,
-    });
-
-    console.log("agentic-dev init complete");
-  } finally {
-    await rm(tempRoot, { recursive: true, force: true });
-  }
-}

package/src/lib/command.js

@@ -1,14 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
-
-export async function runCommand(command, args, options = {}) {
-  const { cwd } = options;
-  return execFileAsync(command, args, { cwd, env: process.env, maxBuffer: 10 * 1024 * 1024 });
-}
-
-export async function runJsonCommand(command, args, options = {}) {
-  const { stdout } = await runCommand(command, args, options);
-  return JSON.parse(stdout);
-}

package/src/lib/fs.js

@@ -1,92 +0,0 @@
-import { mkdir, readdir, readFile, stat, writeFile, copyFile } from "node:fs/promises";
-import path from "node:path";
-
-const COPY_EXCLUDES = new Set([
-  ".git",
-  "node_modules",
-  ".pnpm-store",
-  ".venv",
-  "__pycache__",
-  ".pytest_cache",
-  "dist",
-  "build",
-  "coverage",
-]);
-
-export async function ensureDirectory(targetPath) {
-  await mkdir(targetPath, { recursive: true });
-}
-
-export async function writeJsonFile(targetPath, payload) {
-  await ensureDirectory(path.dirname(targetPath));
-  await writeFile(targetPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-}
-
-export async function readJsonFile(targetPath) {
-  return JSON.parse(await readFile(targetPath, "utf8"));
-}
-
-export async function assertEmptyRepoRoot(cwd) {
-  const entries = await readdir(cwd, { withFileTypes: true });
-  const materialEntries = entries.filter((entry) => entry.name !== ".git");
-
-  if (materialEntries.length > 0) {
-    const names = materialEntries.map((entry) => entry.name).join(", ");
-    throw new Error(
-      `init must run inside an empty git repo root. Remove existing entries first: ${names}`,
-    );
-  }
-}
-
-export async function copyDirectory(sourceDir, targetDir) {
-  const entries = await readdir(sourceDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    if (COPY_EXCLUDES.has(entry.name)) {
-      continue;
-    }
-
-    const sourcePath = path.join(sourceDir, entry.name);
-    const targetPath = path.join(targetDir, entry.name);
-
-    if (entry.isDirectory()) {
-      await ensureDirectory(targetPath);
-      await copyDirectory(sourcePath, targetPath);
-      continue;
-    }
-
-    if (entry.isFile()) {
-      await ensureDirectory(path.dirname(targetPath));
-      await copyFile(sourcePath, targetPath);
-    }
-  }
-}
-
-export async function walkFiles(rootDir, visitor) {
-  const entries = await readdir(rootDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === ".git") {
-      continue;
-    }
-
-    const fullPath = path.join(rootDir, entry.name);
-    if (entry.isDirectory()) {
-      await walkFiles(fullPath, visitor);
-      continue;
-    }
-
-    if (entry.isFile()) {
-      await visitor(fullPath);
-    }
-  }
-}
-
-export async function isProbablyTextFile(filePath) {
-  const fileStat = await stat(filePath);
-  if (fileStat.size === 0) {
-    return true;
-  }
-
-  const sample = await readFile(filePath);
-  return !sample.includes(0);
-}

package/src/lib/git.js

@@ -1,57 +0,0 @@
-import { stat } from "node:fs/promises";
-import path from "node:path";
-
-import { runCommand } from "./command.js";
-
-function parseRemoteUrl(remoteUrl) {
-  const sshMatch = remoteUrl.match(/^git@github\.com:(?<owner>[^/]+)\/(?<repo>[^/.]+?)(?:\.git)?$/);
-  if (sshMatch?.groups) {
-    return { owner: sshMatch.groups.owner, repo: sshMatch.groups.repo };
-  }
-
-  const httpsMatch = remoteUrl.match(
-    /^https:\/\/github\.com\/(?<owner>[^/]+)\/(?<repo>[^/.]+?)(?:\.git)?$/,
-  );
-  if (httpsMatch?.groups) {
-    return { owner: httpsMatch.groups.owner, repo: httpsMatch.groups.repo };
-  }
-
-  return null;
-}
-
-export async function validateGitRepoRoot(cwd) {
-  try {
-    await stat(path.join(cwd, ".git"));
-  } catch {
-    throw new Error("current directory must already contain a .git entry");
-  }
-}
-
-export async function readOriginRemote(cwd) {
-  try {
-    const { stdout } = await runCommand("git", ["config", "--get", "remote.origin.url"], { cwd });
-    const remoteUrl = stdout.trim();
-    if (!remoteUrl) {
-      return null;
-    }
-
-    return parseRemoteUrl(remoteUrl);
-  } catch {
-    return null;
-  }
-}
-
-export async function checkoutRepository(nameWithOwner, ref, targetDir) {
-  const url = `https://github.com/${nameWithOwner}.git`;
-  await runCommand("git", ["init", targetDir]);
-  await runCommand("git", ["-C", targetDir, "remote", "add", "origin", url]);
-  await runCommand("git", ["-C", targetDir, "fetch", "--depth", "1", "origin", ref]);
-  await runCommand("git", ["-C", targetDir, "checkout", "FETCH_HEAD"]);
-}
-
-export async function readGitCommit(cwd) {
-  const { stdout } = await runCommand("git", ["-C", cwd, "rev-parse", "HEAD"]);
-  return stdout.trim();
-}
-
-export { parseRemoteUrl };

package/src/lib/github.js

@@ -1,77 +0,0 @@
-import { runCommand, runJsonCommand } from "./command.js";
-
-function normalizeRepository(repository) {
-  return {
-    name: repository.name,
-    nameWithOwner: repository.nameWithOwner,
-    url: repository.url,
-    defaultBranch: repository.defaultBranchRef?.name ?? "main",
-  };
-}
-
-export async function assertGhCliAuthenticated() {
-  try {
-    await runCommand("gh", ["auth", "status"]);
-  } catch {
-    throw new Error(
-      "GitHub CLI authentication is required. Configure gh auth or GH_TOKEN with repo/project scope first.",
-    );
-  }
-}
-
-export async function listTemplateRepositories(owner) {
-  const repositories = await runJsonCommand("gh", [
-    "repo",
-    "list",
-    owner,
-    "--limit",
-    "200",
-    "--json",
-    "name,nameWithOwner,url,defaultBranchRef,isArchived",
-  ]);
-
-  return repositories
-    .filter((repository) => !repository.isArchived && repository.name.startsWith("template-"))
-    .map(normalizeRepository)
-    .sort((left, right) => left.name.localeCompare(right.name));
-}
-
-export async function getRepositoryMetadata(nameWithOwner) {
-  const repository = await runJsonCommand("gh", [
-    "repo",
-    "view",
-    nameWithOwner,
-    "--json",
-    "name,nameWithOwner,url,defaultBranchRef",
-  ]);
-  return normalizeRepository(repository);
-}
-
-export async function ensureGitHubRepositoryExists(nameWithOwner) {
-  await getRepositoryMetadata(nameWithOwner);
-}
-
-export async function createProject(owner, title) {
-  return runJsonCommand("gh", [
-    "project",
-    "create",
-    "--owner",
-    owner,
-    "--title",
-    title,
-    "--format",
-    "json",
-  ]);
-}
-
-export async function getProject(owner, number) {
-  return runJsonCommand("gh", [
-    "project",
-    "view",
-    String(number),
-    "--owner",
-    owner,
-    "--format",
-    "json",
-  ]);
-}

package/src/lib/prompt.js

@@ -1,52 +0,0 @@
-import readline from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-
-function createInterface() {
-  return readline.createInterface({ input, output });
-}
-
-export async function promptText(label, defaultValue) {
-  const rl = createInterface();
-  const suffix = defaultValue ? ` [${defaultValue}]` : "";
-  const answer = await rl.question(`${label}${suffix}: `);
-  rl.close();
-  return answer.trim() || defaultValue;
-}
-
-export async function confirm(label, defaultValue = true) {
-  const rl = createInterface();
-  const defaultLabel = defaultValue ? "Y/n" : "y/N";
-  const answer = await rl.question(`${label} [${defaultLabel}]: `);
-  rl.close();
-
-  const normalized = answer.trim().toLowerCase();
-  if (!normalized) {
-    return defaultValue;
-  }
-  return normalized === "y" || normalized === "yes";
-}
-
-export async function selectFromList(label, options) {
-  if (options.length === 0) {
-    throw new Error("selection requires at least one option");
-  }
-
-  console.log(label);
-  options.forEach((option, index) => {
-    console.log(`  ${index + 1}. ${option}`);
-  });
-
-  const rl = createInterface();
-  const answer = await rl.question("Select a number [1]: ");
-  rl.close();
-
-  if (!answer.trim()) {
-    return 0;
-  }
-
-  const index = Number.parseInt(answer.trim(), 10) - 1;
-  if (!Number.isInteger(index) || index < 0 || index >= options.length) {
-    throw new Error(`invalid selection: ${answer}`);
-  }
-  return index;
-}

package/src/lib/system.js

@@ -1,15 +0,0 @@
-import { runCommand } from "./command.js";
-
-export async function assertCommandAvailable(command) {
-  try {
-    await runCommand("which", [command]);
-  } catch {
-    throw new Error(`required command not found in PATH: ${command}`);
-  }
-}
-
-export async function assertRequiredCommands(commands) {
-  for (const command of commands) {
-    await assertCommandAvailable(command);
-  }
-}