@alxyrgin/agent-forge 1.0.0

package/dist/index.js

@@ -0,0 +1,808 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import chalk from "chalk";
+import ora from "ora";
+
+// src/prompts/project-setup.ts
+import inquirer from "inquirer";
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+var STACK_CHOICES = [
+  { name: "Python", value: "python" },
+  { name: "TypeScript / Node.js", value: "typescript" },
+  { name: "Go", value: "go" },
+  { name: "Rust", value: "rust" },
+  { name: "Other", value: "other" }
+];
+var FRAMEWORK_MAP = {
+  python: ["FastAPI", "Django", "Flask", "None"],
+  typescript: ["Next.js", "Express", "Fastify", "None"],
+  go: ["Gin", "Echo", "Chi", "None"],
+  rust: ["Actix", "Axum", "Rocket", "None"],
+  other: ["None"]
+};
+var TEST_MAP = {
+  python: { framework: "pytest", command: "pytest" },
+  typescript: { framework: "vitest", command: "npx vitest run" },
+  go: { framework: "go test", command: "go test ./..." },
+  rust: { framework: "cargo test", command: "cargo test" },
+  other: { framework: "custom", command: 'echo "no tests configured"' }
+};
+async function promptProjectSetup(targetDir) {
+  const base = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      default: targetDir.split("/").pop()
+    },
+    {
+      type: "input",
+      name: "projectDescription",
+      message: "Project description:",
+      default: "AI-driven project"
+    },
+    {
+      type: "list",
+      name: "stack",
+      message: "Technology stack:",
+      choices: STACK_CHOICES
+    }
+  ]);
+  const frameworks = FRAMEWORK_MAP[base.stack] || ["None"];
+  const frameworkAnswer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "framework",
+      message: "Framework:",
+      choices: frameworks
+    }
+  ]);
+  const testDefaults = TEST_MAP[base.stack] || TEST_MAP.other;
+  const dirs = await inquirer.prompt([
+    {
+      type: "input",
+      name: "testFramework",
+      message: "Test framework:",
+      default: testDefaults.framework
+    },
+    {
+      type: "input",
+      name: "testCommand",
+      message: "Test command:",
+      default: testDefaults.command
+    },
+    {
+      type: "input",
+      name: "srcDir",
+      message: "Source directory:",
+      default: "src/"
+    },
+    {
+      type: "input",
+      name: "testDir",
+      message: "Test directory:",
+      default: base.stack === "python" ? "src/tests/" : "tests/"
+    }
+  ]);
+  const team = [];
+  let addMore = true;
+  let first = true;
+  while (addMore) {
+    const member = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: first ? "Team member name:" : "Next team member name (leave empty to stop):",
+        default: first ? void 0 : ""
+      }
+    ]);
+    if (!member.name) break;
+    const details = await inquirer.prompt([
+      {
+        type: "input",
+        name: "role",
+        message: `${member.name}'s role:`,
+        default: "developer"
+      },
+      {
+        type: "input",
+        name: "email",
+        message: `${member.name}'s email:`
+      }
+    ]);
+    team.push({ name: member.name, role: details.role, email: details.email });
+    first = false;
+    if (team.length >= 10) break;
+    const cont = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "addMore",
+        message: "Add another team member?",
+        default: false
+      }
+    ]);
+    addMore = cont.addMore;
+  }
+  const milestones = [];
+  const addMilestones = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "add",
+      message: "Add milestones?",
+      default: false
+    }
+  ]);
+  if (addMilestones.add) {
+    let addMoreMs = true;
+    while (addMoreMs) {
+      const ms = await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Milestone name:"
+        },
+        {
+          type: "input",
+          name: "deadline",
+          message: "Deadline (YYYY-MM-DD):"
+        },
+        {
+          type: "input",
+          name: "description",
+          message: "Description (optional):",
+          default: ""
+        }
+      ]);
+      milestones.push({
+        name: ms.name,
+        deadline: ms.deadline,
+        description: ms.description || void 0
+      });
+      const cont = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "addMore",
+          message: "Add another milestone?",
+          default: false
+        }
+      ]);
+      addMoreMs = cont.addMore;
+    }
+  }
+  const config = await inquirer.prompt([
+    {
+      type: "list",
+      name: "agentPreset",
+      message: "Agent preset:",
+      choices: [
+        { name: "Core (8 agents \u2014 recommended)", value: "core" },
+        { name: "Full (11 agents)", value: "full" },
+        { name: "Minimal (4 agents)", value: "minimal" }
+      ]
+    },
+    {
+      type: "list",
+      name: "language",
+      message: "Instructions language:",
+      choices: [
+        { name: "Russian", value: "ru" },
+        { name: "English", value: "en" }
+      ]
+    },
+    {
+      type: "list",
+      name: "commitStyle",
+      message: "Commit style:",
+      choices: [
+        { name: "Standard (type(scope): description)", value: "standard" },
+        { name: "Conventional Commits", value: "conventional" }
+      ]
+    }
+  ]);
+  return {
+    projectName: base.projectName,
+    projectDescription: base.projectDescription,
+    stack: base.stack,
+    framework: frameworkAnswer.framework,
+    testFramework: dirs.testFramework,
+    testCommand: dirs.testCommand,
+    srcDir: dirs.srcDir,
+    testDir: dirs.testDir,
+    team,
+    milestones,
+    agentPreset: config.agentPreset,
+    language: config.language,
+    commitStyle: config.commitStyle,
+    today: today(),
+    targetDir
+  };
+}
+function getDefaultContext(targetDir) {
+  return {
+    projectName: targetDir.split("/").pop() || "my-project",
+    projectDescription: "AI-driven project",
+    stack: "typescript",
+    framework: "None",
+    testFramework: "vitest",
+    testCommand: "npx vitest run",
+    srcDir: "src/",
+    testDir: "tests/",
+    team: [{ name: "Developer", role: "developer", email: "" }],
+    milestones: [],
+    agentPreset: "core",
+    language: "en",
+    commitStyle: "standard",
+    today: today(),
+    targetDir
+  };
+}
+
+// src/generators/memory-bank.ts
+import path3 from "path";
+
+// src/utils/template.ts
+import ejs from "ejs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/fs.ts
+import fs from "fs-extra";
+import path from "path";
+async function ensureDir(dirPath) {
+  await fs.ensureDir(dirPath);
+}
+async function writeFileSafe(filePath, content, overwrite = false) {
+  const dir = path.dirname(filePath);
+  await fs.ensureDir(dir);
+  if (await fs.pathExists(filePath)) {
+    if (!overwrite) {
+      return "skipped";
+    }
+    await fs.writeFile(filePath, content, "utf-8");
+    return "overwritten";
+  }
+  await fs.writeFile(filePath, content, "utf-8");
+  return "created";
+}
+async function fileExists(filePath) {
+  return fs.pathExists(filePath);
+}
+async function readFile(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+
+// src/utils/template.ts
+import fs2 from "fs";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+var distPath = path2.resolve(__dirname, "../templates");
+var devPath = path2.resolve(__dirname, "../../templates");
+var TEMPLATES_DIR = fs2.existsSync(distPath) ? distPath : devPath;
+async function renderTemplate(templatePath, data) {
+  const fullPath = path2.join(TEMPLATES_DIR, templatePath);
+  const template = await readFile(fullPath);
+  return ejs.render(template, data, {
+    filename: fullPath,
+    async: false
+  });
+}
+
+// src/generators/memory-bank.ts
+var MEMORY_FILES = [
+  "active-context.md",
+  "progress.md",
+  "project-brief.md",
+  "decisions.md",
+  "tech-stack.md",
+  "tech-debt.md",
+  "patterns.md",
+  "troubleshooting.md"
+];
+async function generateMemoryBank(ctx, overwrite) {
+  const result = {
+    filesCreated: [],
+    filesSkipped: [],
+    errors: []
+  };
+  const templateData = {
+    ...ctx,
+    defaultBranch: "main"
+  };
+  for (const file of MEMORY_FILES) {
+    try {
+      const content = await renderTemplate(`memory/${file}.ejs`, templateData);
+      const outputPath = path3.join(ctx.targetDir, "dev-infra/memory", file);
+      const status = await writeFileSafe(outputPath, content, overwrite);
+      if (status === "skipped") {
+        result.filesSkipped.push(outputPath);
+      } else {
+        result.filesCreated.push(outputPath);
+      }
+    } catch (err) {
+      result.errors.push(`Memory ${file}: ${err}`);
+    }
+  }
+  return result;
+}
+
+// src/generators/agents.ts
+import path4 from "path";
+var CORE_AGENTS = [
+  "analyst",
+  "architect",
+  "developer",
+  "unit-tester",
+  "reviewer",
+  "security-auditor",
+  "doc-writer",
+  "progress-tracker"
+];
+var EXTRA_AGENTS = [
+  "planner",
+  "integration-tester",
+  "acceptance-tester"
+];
+var MINIMAL_AGENTS = [
+  "analyst",
+  "developer",
+  "unit-tester",
+  "reviewer"
+];
+function getAgentList(preset) {
+  const agents = [];
+  const coreList = preset === "minimal" ? MINIMAL_AGENTS : CORE_AGENTS;
+  for (const name of coreList) {
+    agents.push({ name, dir: "core" });
+  }
+  if (preset === "full") {
+    for (const name of EXTRA_AGENTS) {
+      agents.push({ name, dir: "extra" });
+    }
+  }
+  return agents;
+}
+async function generateAgents(ctx, overwrite) {
+  const result = {
+    filesCreated: [],
+    filesSkipped: [],
+    errors: []
+  };
+  const agents = getAgentList(ctx.agentPreset);
+  const templateData = {
+    ...ctx,
+    defaultBranch: "main"
+  };
+  for (const agent of agents) {
+    try {
+      const content = await renderTemplate(
+        `agents/${agent.dir}/${agent.name}.md.ejs`,
+        templateData
+      );
+      const outputPath = path4.join(ctx.targetDir, ".claude/agents", `${agent.name}.md`);
+      const status = await writeFileSafe(outputPath, content, overwrite);
+      if (status === "skipped") {
+        result.filesSkipped.push(outputPath);
+      } else {
+        result.filesCreated.push(outputPath);
+      }
+    } catch (err) {
+      result.errors.push(`Agent ${agent.name}: ${err}`);
+    }
+  }
+  return result;
+}
+
+// src/generators/skills.ts
+import path5 from "path";
+var SKILLS = [
+  "start-session",
+  "end-session",
+  "take-task",
+  "complete-task",
+  "status",
+  "plan",
+  "review"
+];
+async function generateSkills(ctx, overwrite) {
+  const result = {
+    filesCreated: [],
+    filesSkipped: [],
+    errors: []
+  };
+  const templateData = {
+    ...ctx,
+    defaultBranch: "main"
+  };
+  for (const skill of SKILLS) {
+    try {
+      const content = await renderTemplate(
+        `skills/core/${skill}/SKILL.md.ejs`,
+        templateData
+      );
+      const outputPath = path5.join(ctx.targetDir, `.claude/skills/${skill}`, "SKILL.md");
+      const status = await writeFileSafe(outputPath, content, overwrite);
+      if (status === "skipped") {
+        result.filesSkipped.push(outputPath);
+      } else {
+        result.filesCreated.push(outputPath);
+      }
+    } catch (err) {
+      result.errors.push(`Skill ${skill}: ${err}`);
+    }
+  }
+  return result;
+}
+
+// src/generators/rules.ts
+import path6 from "path";
+var RULES = [
+  "commit-conventions",
+  "development-cycle",
+  "testing-standards"
+];
+async function generateRules(ctx, overwrite) {
+  const result = {
+    filesCreated: [],
+    filesSkipped: [],
+    errors: []
+  };
+  const templateData = {
+    ...ctx,
+    defaultBranch: "main"
+  };
+  for (const rule of RULES) {
+    try {
+      const content = await renderTemplate(`rules/${rule}.md.ejs`, templateData);
+      const outputPath = path6.join(ctx.targetDir, ".claude/rules", `${rule}.md`);
+      const status = await writeFileSafe(outputPath, content, overwrite);
+      if (status === "skipped") {
+        result.filesSkipped.push(outputPath);
+      } else {
+        result.filesCreated.push(outputPath);
+      }
+    } catch (err) {
+      result.errors.push(`Rule ${rule}: ${err}`);
+    }
+  }
+  return result;
+}
+
+// src/generators/claude-md.ts
+import path7 from "path";
+async function generateClaudeMd(ctx, overwrite) {
+  const result = {
+    filesCreated: [],
+    filesSkipped: [],
+    errors: []
+  };
+  const templateData = {
+    ...ctx,
+    defaultBranch: "main"
+  };
+  try {
+    const content = await renderTemplate("root/CLAUDE.md.ejs", templateData);
+    const outputPath = path7.join(ctx.targetDir, ".claude/CLAUDE.md");
+    const status = await writeFileSafe(outputPath, content, overwrite);
+    if (status === "skipped") {
+      result.filesSkipped.push(outputPath);
+    } else {
+      result.filesCreated.push(outputPath);
+    }
+  } catch (err) {
+    result.errors.push(`CLAUDE.md: ${err}`);
+  }
+  try {
+    const content = await renderTemplate("root/settings.json.ejs", templateData);
+    const outputPath = path7.join(ctx.targetDir, ".claude/settings.json");
+    const status = await writeFileSafe(outputPath, content, overwrite);
+    if (status === "skipped") {
+      result.filesSkipped.push(outputPath);
+    } else {
+      result.filesCreated.push(outputPath);
+    }
+  } catch (err) {
+    result.errors.push(`settings.json: ${err}`);
+  }
+  return result;
+}
+
+// src/generators/infra.ts
+import path8 from "path";
+async function generateInfra(ctx, overwrite) {
+  const result = {
+    filesCreated: [],
+    filesSkipped: [],
+    errors: []
+  };
+  const templateData = {
+    ...ctx,
+    defaultBranch: "main"
+  };
+  try {
+    const content = await renderTemplate("tasks/tasks.json.ejs", templateData);
+    const outputPath = path8.join(ctx.targetDir, "dev-infra/tasks/tasks.json");
+    const status = await writeFileSafe(outputPath, content, overwrite);
+    if (status === "skipped") {
+      result.filesSkipped.push(outputPath);
+    } else {
+      result.filesCreated.push(outputPath);
+    }
+  } catch (err) {
+    result.errors.push(`tasks.json: ${err}`);
+  }
+  const dirs = [
+    "dev-infra/sessions",
+    "dev-infra/tests/acceptance",
+    "dev-infra/tests/pmi",
+    "dev-infra/tests/results"
+  ];
+  for (const dir of dirs) {
+    try {
+      const dirPath = path8.join(ctx.targetDir, dir);
+      await ensureDir(dirPath);
+      const gitkeepPath = path8.join(dirPath, ".gitkeep");
+      const status = await writeFileSafe(gitkeepPath, "", overwrite);
+      if (status === "skipped") {
+        result.filesSkipped.push(gitkeepPath);
+      } else {
+        result.filesCreated.push(gitkeepPath);
+      }
+    } catch (err) {
+      result.errors.push(`Dir ${dir}: ${err}`);
+    }
+  }
+  try {
+    const manifest = {
+      version: "1.0.0",
+      createdAt: ctx.today,
+      projectName: ctx.projectName,
+      agentPreset: ctx.agentPreset,
+      language: ctx.language,
+      expectedFiles: getExpectedFiles(ctx)
+    };
+    const outputPath = path8.join(ctx.targetDir, ".claude-forge.json");
+    const status = await writeFileSafe(
+      outputPath,
+      JSON.stringify(manifest, null, 2) + "\n",
+      overwrite
+    );
+    if (status === "skipped") {
+      result.filesSkipped.push(outputPath);
+    } else {
+      result.filesCreated.push(outputPath);
+    }
+  } catch (err) {
+    result.errors.push(`.claude-forge.json: ${err}`);
+  }
+  return result;
+}
+function getExpectedFiles(ctx) {
+  const files = [
+    ".claude/CLAUDE.md",
+    ".claude/settings.json",
+    ".claude-forge.json",
+    "dev-infra/tasks/tasks.json",
+    "dev-infra/memory/active-context.md",
+    "dev-infra/memory/progress.md",
+    "dev-infra/memory/project-brief.md",
+    "dev-infra/memory/decisions.md",
+    "dev-infra/memory/tech-stack.md",
+    "dev-infra/memory/tech-debt.md",
+    "dev-infra/memory/patterns.md",
+    "dev-infra/memory/troubleshooting.md"
+  ];
+  files.push(
+    ".claude/rules/commit-conventions.md",
+    ".claude/rules/development-cycle.md",
+    ".claude/rules/testing-standards.md"
+  );
+  const skills = [
+    "start-session",
+    "end-session",
+    "take-task",
+    "complete-task",
+    "status",
+    "plan",
+    "review"
+  ];
+  for (const skill of skills) {
+    files.push(`.claude/skills/${skill}/SKILL.md`);
+  }
+  const coreAgents = [
+    "analyst",
+    "architect",
+    "developer",
+    "unit-tester",
+    "reviewer",
+    "security-auditor",
+    "doc-writer",
+    "progress-tracker"
+  ];
+  const minimalAgents = ["analyst", "developer", "unit-tester", "reviewer"];
+  const extraAgents = ["planner", "integration-tester", "acceptance-tester"];
+  const agents = ctx.agentPreset === "minimal" ? minimalAgents : ctx.agentPreset === "full" ? [...coreAgents, ...extraAgents] : coreAgents;
+  for (const agent of agents) {
+    files.push(`.claude/agents/${agent}.md`);
+  }
+  return files;
+}
+
+// src/generators/index.ts
+async function generateAll(ctx, overwrite = false) {
+  const result = {
+    filesCreated: [],
+    filesSkipped: [],
+    errors: []
+  };
+  const generators = [
+    generateClaudeMd,
+    generateAgents,
+    generateSkills,
+    generateRules,
+    generateMemoryBank,
+    generateInfra
+  ];
+  for (const generator of generators) {
+    try {
+      const partial = await generator(ctx, overwrite);
+      result.filesCreated.push(...partial.filesCreated);
+      result.filesSkipped.push(...partial.filesSkipped);
+      result.errors.push(...partial.errors);
+    } catch (err) {
+      result.errors.push(`Generator error: ${err}`);
+    }
+  }
+  return result;
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  const targetDir = process.cwd();
+  console.log();
+  console.log(chalk.bold("  agent-forge v1.0.0"));
+  console.log(chalk.dim("  AI-driven Development Framework for Claude Code"));
+  console.log();
+  let ctx;
+  if (options.yes) {
+    ctx = getDefaultContext(targetDir);
+    console.log(chalk.dim("  Using default configuration (--yes)"));
+    console.log();
+  } else {
+    ctx = await promptProjectSetup(targetDir);
+    console.log();
+  }
+  const spinner = ora("Creating project structure...").start();
+  try {
+    const result = await generateAll(ctx, options.overwrite ?? false);
+    spinner.succeed(
+      chalk.green(`${result.filesCreated.length} files created`)
+    );
+    if (result.filesSkipped.length > 0) {
+      console.log(
+        chalk.yellow(`  ${result.filesSkipped.length} files skipped (already exist)`)
+      );
+    }
+    if (result.errors.length > 0) {
+      console.log(chalk.red(`  ${result.errors.length} errors:`));
+      for (const err of result.errors) {
+        console.log(chalk.red(`    - ${err}`));
+      }
+    }
+    console.log();
+    console.log(chalk.bold("  Next steps:"));
+    console.log(chalk.dim("  1. Open Claude Code in this directory"));
+    console.log(chalk.dim("  2. /start-session \u2014 begin your first session"));
+    console.log(chalk.dim("  3. /plan init \u2014 create tasks from your documentation"));
+    console.log();
+  } catch (err) {
+    spinner.fail(chalk.red("Failed to create project structure"));
+    console.error(err);
+    process.exit(1);
+  }
+}
+
+// src/commands/doctor.ts
+import path9 from "path";
+import chalk2 from "chalk";
+async function doctorCommand() {
+  const targetDir = process.cwd();
+  console.log();
+  console.log(chalk2.bold("  agent-forge doctor"));
+  console.log(chalk2.dim("  Checking project structure integrity..."));
+  console.log();
+  const manifestPath = path9.join(targetDir, ".claude-forge.json");
+  const manifestExists = await fileExists(manifestPath);
+  if (!manifestExists) {
+    console.log(chalk2.red("  .claude-forge.json not found"));
+    console.log(chalk2.dim("  Run `agent-forge init` first to initialize the project."));
+    console.log();
+    process.exit(1);
+  }
+  const manifestRaw = await readFile(manifestPath);
+  let manifest;
+  try {
+    manifest = JSON.parse(manifestRaw);
+  } catch {
+    console.log(chalk2.red("  .claude-forge.json is corrupted"));
+    process.exit(1);
+  }
+  console.log(chalk2.dim(`  Project: ${manifest.projectName}`));
+  console.log(chalk2.dim(`  Version: ${manifest.version}`));
+  console.log();
+  const checks = [];
+  let okCount = 0;
+  let failCount = 0;
+  for (const file of manifest.expectedFiles) {
+    const filePath = path9.join(targetDir, file);
+    const exists = await fileExists(filePath);
+    const check = {
+      name: file,
+      path: filePath,
+      exists,
+      ok: exists
+    };
+    if (exists) {
+      try {
+        const content = await readFile(filePath);
+        if (content.trim().length === 0) {
+          check.ok = false;
+          check.message = "File is empty";
+        }
+      } catch {
+        check.ok = false;
+        check.message = "Cannot read file";
+      }
+    } else {
+      check.message = "File not found";
+    }
+    checks.push(check);
+    if (check.ok) okCount++;
+    else failCount++;
+  }
+  const categories = {};
+  for (const check of checks) {
+    const category = check.name.startsWith(".claude/agents") ? "Agents" : check.name.startsWith(".claude/skills") ? "Skills" : check.name.startsWith(".claude/rules") ? "Rules" : check.name.startsWith(".claude/") ? "Claude Config" : check.name.startsWith("dev-infra/memory") ? "Memory Bank" : check.name.startsWith("dev-infra/") ? "Infrastructure" : "Other";
+    if (!categories[category]) categories[category] = [];
+    categories[category].push(check);
+  }
+  for (const [category, items] of Object.entries(categories)) {
+    const allOk = items.every((c) => c.ok);
+    const icon = allOk ? chalk2.green("OK") : chalk2.red("!!");
+    console.log(`  ${icon} ${chalk2.bold(category)}`);
+    for (const item of items) {
+      if (item.ok) {
+        console.log(chalk2.green(`     + ${item.name}`));
+      } else {
+        console.log(chalk2.red(`     - ${item.name} (${item.message})`));
+      }
+    }
+    console.log();
+  }
+  console.log(chalk2.bold("  Summary"));
+  console.log(chalk2.green(`    OK: ${okCount}`));
+  if (failCount > 0) {
+    console.log(chalk2.red(`    Missing/broken: ${failCount}`));
+    console.log();
+    console.log(chalk2.dim("  Run `agent-forge init --overwrite` to regenerate missing files."));
+  } else {
+    console.log(chalk2.green("    All checks passed!"));
+  }
+  console.log();
+  if (failCount > 0) {
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("agent-forge").description("AI-driven Development Framework for Claude Code").version("1.0.0");
+program.command("init").description("Initialize AI-driven development infrastructure in the current project").option("-y, --yes", "Skip prompts and use defaults").option("--overwrite", "Overwrite existing files").action(initCommand);
+program.command("doctor").description("Check integrity of the generated structure").action(doctorCommand);
+program.parse();
+//# sourceMappingURL=index.js.map