@alxyrgin/agent-forge 3.0.0 → 3.2.0

package/dist/index.js

@@ -470,7 +470,8 @@ var EXTRA_SKILLS = [
   "security",
   "spec",
   "techspec",
-  "prompts"
+  "prompts",
+  "sync-linear"
 ];
 function getSkillList(preset) {
   const skills = [];
@@ -525,7 +526,8 @@ var RULES = [
   "context-loading",
   "agent-output-format",
   "quality-gates",
-  "rollback-protocol"
+  "rollback-protocol",
+  "linear-sync"
 ];
 async function generateRules(ctx, overwrite) {
   const result = {
@@ -556,6 +558,69 @@ async function generateRules(ctx, overwrite) {
 
 // src/generators/claude-md.ts
 import path7 from "path";
+
+// src/utils/merge.ts
+function parseSections(markdown) {
+  const lines = markdown.split("\n");
+  let preamble = "";
+  const sections = [];
+  let currentHeader = null;
+  let currentContent = "";
+  let foundFirstSection = false;
+  for (const line of lines) {
+    if (/^## /.test(line)) {
+      if (foundFirstSection && currentHeader !== null) {
+        sections.push({ header: currentHeader, content: currentContent });
+      }
+      if (!foundFirstSection) {
+        preamble = currentContent;
+        foundFirstSection = true;
+        currentContent = "";
+      }
+      currentHeader = line;
+      currentContent = "";
+    } else {
+      currentContent += line + "\n";
+    }
+  }
+  if (foundFirstSection && currentHeader !== null) {
+    sections.push({ header: currentHeader, content: currentContent });
+  } else {
+    preamble = currentContent;
+  }
+  return { preamble, sections };
+}
+function normalizeHeader(header) {
+  return header.replace(/^##\s+/, "").trim().toLowerCase();
+}
+function mergeSections(existing, template) {
+  if (!existing || !existing.trim()) {
+    return template;
+  }
+  const parsedExisting = parseSections(existing);
+  const parsedTemplate = parseSections(template);
+  if (parsedExisting.sections.length === 0) {
+    return template;
+  }
+  const templateHeaders = new Set(
+    parsedTemplate.sections.map((s) => normalizeHeader(s.header))
+  );
+  const userSections = parsedExisting.sections.filter(
+    (s) => !templateHeaders.has(normalizeHeader(s.header))
+  );
+  let result = parsedTemplate.preamble;
+  for (const section of parsedTemplate.sections) {
+    result += section.header + "\n";
+    result += section.content;
+  }
+  for (const section of userSections) {
+    result += section.header + "\n";
+    result += section.content;
+  }
+  return result;
+}
+
+// src/generators/claude-md.ts
 async function generateClaudeMd(ctx, overwrite) {
   const result = {
     filesCreated: [],
@@ -569,11 +634,19 @@ async function generateClaudeMd(ctx, overwrite) {
   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 {
+    const exists = await fileExists(outputPath);
+    if (exists && overwrite) {
+      const existingContent = await readFile(outputPath);
+      const merged = mergeSections(existingContent, content);
+      await writeFileSafe(outputPath, merged, true);
       result.filesCreated.push(outputPath);
+    } else {
+      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}`);
@@ -617,11 +690,24 @@ async function generateInfra(ctx, overwrite) {
   } catch (err) {
     result.errors.push(`tasks.json: ${err}`);
   }
+  try {
+    const content = await renderTemplate("config/linear-mapping.json.ejs", templateData);
+    const outputPath = path8.join(ctx.targetDir, "dev-infra/config/linear-mapping.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(`linear-mapping.json: ${err}`);
+  }
   const dirs = [
     "dev-infra/sessions",
     "dev-infra/tests/acceptance",
     "dev-infra/tests/pmi",
-    "dev-infra/tests/results"
+    "dev-infra/tests/results",
+    "dev-infra/config"
   ];
   for (const dir of dirs) {
     try {
@@ -639,14 +725,7 @@ async function generateInfra(ctx, overwrite) {
     }
   }
   try {
-    const manifest = {
-      version: "3.0.0",
-      createdAt: ctx.today,
-      projectName: ctx.projectName,
-      agentPreset: ctx.agentPreset,
-      language: ctx.language,
-      expectedFiles: getExpectedFiles(ctx)
-    };
+    const manifest = buildManifest(ctx);
     const outputPath = path8.join(ctx.targetDir, ".claude-forge.json");
     const status = await writeFileSafe(
       outputPath,
@@ -663,6 +742,25 @@ async function generateInfra(ctx, overwrite) {
   }
   return result;
 }
+function buildManifest(ctx) {
+  return {
+    version: "3.2.0",
+    createdAt: ctx.today,
+    updatedAt: ctx.today,
+    projectName: ctx.projectName,
+    projectDescription: ctx.projectDescription,
+    language: ctx.language,
+    agentPreset: ctx.agentPreset,
+    stack: ctx.stack,
+    framework: ctx.framework,
+    testFramework: ctx.testFramework,
+    testCommand: ctx.testCommand,
+    srcDir: ctx.srcDir,
+    testDir: ctx.testDir,
+    commitStyle: ctx.commitStyle,
+    expectedFiles: getExpectedFiles(ctx)
+  };
+}
 function getExpectedFiles(ctx) {
   const files = [
     ".claude/CLAUDE.md",
@@ -677,7 +775,8 @@ function getExpectedFiles(ctx) {
     "dev-infra/memory/tech-debt.md",
     "dev-infra/memory/patterns.md",
     "dev-infra/memory/troubleshooting.md",
-    "dev-infra/memory/checkpoint.yml"
+    "dev-infra/memory/checkpoint.yml",
+    "dev-infra/config/linear-mapping.json"
   ];
   files.push(".claude/hooks/protect-docs.sh");
   files.push(
@@ -688,7 +787,8 @@ function getExpectedFiles(ctx) {
     ".claude/rules/context-loading.md",
     ".claude/rules/agent-output-format.md",
     ".claude/rules/quality-gates.md",
-    ".claude/rules/rollback-protocol.md"
+    ".claude/rules/rollback-protocol.md",
+    ".claude/rules/linear-sync.md"
   );
   const coreSkills = [
     "start-session",
@@ -713,7 +813,8 @@ function getExpectedFiles(ctx) {
     "security",
     "spec",
     "techspec",
-    "prompts"
+    "prompts",
+    "sync-linear"
   ];
   const skills = ctx.agentPreset === "full" ? [...coreSkills, ...extraSkills] : coreSkills;
   for (const skill of skills) {
@@ -942,10 +1043,152 @@ async function doctorCommand() {
   }
 }
 
+// src/commands/update.ts
+import path11 from "path";
+import chalk3 from "chalk";
+import ora2 from "ora";
+function today2() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function contextFromManifest(manifest, targetDir) {
+  return {
+    projectName: manifest.projectName || targetDir.split("/").pop() || "my-project",
+    projectDescription: manifest.projectDescription || "AI-driven project",
+    stack: manifest.stack || "typescript",
+    framework: manifest.framework || "None",
+    testFramework: manifest.testFramework || "vitest",
+    testCommand: manifest.testCommand || "npx vitest run",
+    srcDir: manifest.srcDir || "src/",
+    testDir: manifest.testDir || "tests/",
+    team: [],
+    milestones: [],
+    agentPreset: manifest.agentPreset || "core",
+    language: manifest.language || "ru",
+    commitStyle: manifest.commitStyle || "standard",
+    today: today2(),
+    targetDir
+  };
+}
+async function updateCommand() {
+  const targetDir = process.cwd();
+  console.log();
+  console.log(chalk3.bold("  agent-forge update v3.0.0"));
+  console.log(chalk3.dim("  Updating framework files..."));
+  console.log();
+  const manifestPath = path11.join(targetDir, ".claude-forge.json");
+  const manifestExists = await fileExists(manifestPath);
+  if (!manifestExists) {
+    console.log(chalk3.red("  .claude-forge.json not found"));
+    console.log(
+      chalk3.dim("  This project is not initialized. Run `agent-forge init` first.")
+    );
+    console.log();
+    process.exit(1);
+  }
+  const manifestRaw = await readFile(manifestPath);
+  let existingManifest;
+  try {
+    existingManifest = JSON.parse(manifestRaw);
+  } catch {
+    console.log(chalk3.red("  .claude-forge.json is corrupted. Cannot update."));
+    console.log(
+      chalk3.dim("  Run `agent-forge init --overwrite` to reinitialize.")
+    );
+    console.log();
+    process.exit(1);
+  }
+  const previousVersion = existingManifest.version || "unknown";
+  const ctx = contextFromManifest(existingManifest, targetDir);
+  const spinner = ora2("Updating framework files...").start();
+  try {
+    const result = {
+      filesCreated: [],
+      filesSkipped: [],
+      errors: []
+    };
+    const frameworkGenerators = [
+      generateClaudeMd,
+      generateAgents,
+      generateSkills,
+      generateRules,
+      generateHooks
+    ];
+    for (const generator of frameworkGenerators) {
+      try {
+        const partial = await generator(ctx, true);
+        result.filesCreated.push(...partial.filesCreated);
+        result.filesSkipped.push(...partial.filesSkipped);
+        result.errors.push(...partial.errors);
+      } catch (err) {
+        result.errors.push(`Generator error: ${err}`);
+      }
+    }
+    const userDataGenerators = [
+      generateMemoryBank,
+      generateInfra
+    ];
+    for (const generator of userDataGenerators) {
+      try {
+        const partial = await generator(ctx, false);
+        result.filesCreated.push(...partial.filesCreated);
+        result.filesSkipped.push(...partial.filesSkipped);
+        result.errors.push(...partial.errors);
+      } catch (err) {
+        result.errors.push(`Generator error: ${err}`);
+      }
+    }
+    const updatedManifest = buildManifest(ctx);
+    updatedManifest.createdAt = existingManifest.createdAt || updatedManifest.createdAt;
+    updatedManifest.updatedAt = today2();
+    await writeFileSafe(
+      manifestPath,
+      JSON.stringify(updatedManifest, null, 2) + "\n",
+      true
+    );
+    spinner.succeed(chalk3.green("Framework files updated"));
+    const newFiles = result.filesCreated.filter((f) => !result.filesSkipped.includes(f));
+    const updatedCount = newFiles.length;
+    const skippedCount = result.filesSkipped.length;
+    console.log();
+    if (updatedCount > 0) {
+      console.log(
+        chalk3.green(`  + ${updatedCount} files updated/added`)
+      );
+    }
+    if (skippedCount > 0) {
+      console.log(
+        chalk3.yellow(`  ~ ${skippedCount} files skipped (user data preserved)`)
+      );
+    }
+    if (result.errors.length > 0) {
+      console.log(chalk3.red(`  ! ${result.errors.length} errors:`));
+      for (const err of result.errors) {
+        console.log(chalk3.red(`    - ${err}`));
+      }
+    }
+    console.log();
+    if (previousVersion !== updatedManifest.version) {
+      console.log(
+        chalk3.dim(`  .claude-forge.json updated: ${previousVersion} -> v${updatedManifest.version}`)
+      );
+    } else {
+      console.log(
+        chalk3.dim(`  .claude-forge.json updated (v${updatedManifest.version})`)
+      );
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(chalk3.red("Failed to update framework files"));
+    console.error(err);
+    process.exit(1);
+  }
+}
+
 // src/index.ts
 var program = new Command();
-program.name("agent-forge").description("AI-driven Development Framework for Claude Code").version("3.0.0");
+program.name("agent-forge").description("AI-driven Development Framework for Claude Code").version("3.2.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.command("update").description("Update framework files to the latest version (preserves user data)").action(updateCommand);
 program.parse();
 //# sourceMappingURL=index.js.map