@sulhadin/orchestrator 3.0.0-beta.8 → 3.0.0-beta.9

package/bin/index.js

@@ -95,6 +95,123 @@ function rmDirRecursive(dir) {
   fs.rmdirSync(dir);
 }
 
+/**
+ * Simple YAML config merge: adds new keys from template, preserves user values.
+ * Works with flat and one-level nested YAML (no deep nesting needed for config.yml).
+ */
+function mergeConfigYaml(userContent, templateContent) {
+  const userLines = userContent.split("\n");
+  const templateLines = templateContent.split("\n");
+
+  // Parse YAML into { key: value } with awareness of sections
+  function parseYaml(lines) {
+    const result = {};
+    let currentSection = null;
+    for (const line of lines) {
+      // Skip comments and empty lines for parsing, but we'll preserve them
+      if (line.trim() === "" || line.trim().startsWith("#")) continue;
+      // Top-level section (no indent)
+      const sectionMatch = line.match(/^(\w[\w_-]*):\s*$/);
+      if (sectionMatch) {
+        currentSection = sectionMatch[1];
+        result[currentSection] = result[currentSection] || {};
+        continue;
+      }
+      // Nested key (2-space indent)
+      const nestedMatch = line.match(/^  (\w[\w_-]*):\s*(.+)?$/);
+      if (nestedMatch && currentSection) {
+        const key = nestedMatch[1];
+        const value = nestedMatch[2] || "";
+        if (!result[currentSection]) result[currentSection] = {};
+        // Check if this is a sub-section (value is empty, next lines are indented more)
+        if (!value) {
+          result[currentSection][key] = result[currentSection][key] || {};
+        } else {
+          result[currentSection][key] = value;
+        }
+        continue;
+      }
+      // Deeper nested key (4-space indent)
+      const deepMatch = line.match(/^    (\w[\w_-]*):\s*(.+)$/);
+      if (deepMatch && currentSection) {
+        // Find parent key (last nested key without value)
+        const parentKeys = Object.keys(result[currentSection] || {});
+        const parentKey = parentKeys.reverse().find(
+          (k) => typeof result[currentSection][k] === "object"
+        );
+        if (parentKey) {
+          result[currentSection][parentKey][deepMatch[1]] = deepMatch[2];
+        }
+      }
+    }
+    return result;
+  }
+
+  const userParsed = parseYaml(userLines);
+  const templateParsed = parseYaml(templateLines);
+
+  // Build merged config: start with template (has comments + structure), fill with user values
+  const merged = [];
+  let currentSection = null;
+  let currentSubSection = null;
+
+  for (const line of templateLines) {
+    const sectionMatch = line.match(/^(\w[\w_-]*):\s*$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      currentSubSection = null;
+      merged.push(line);
+      continue;
+    }
+
+    const nestedMatch = line.match(/^  (\w[\w_-]*):\s*(.+)?$/);
+    if (nestedMatch && currentSection) {
+      const key = nestedMatch[1];
+      const templateValue = nestedMatch[2] || "";
+
+      if (!templateValue) {
+        // Sub-section header (e.g., "models:")
+        currentSubSection = key;
+        merged.push(line);
+        continue;
+      }
+
+      // Has a value → this is a flat key, reset sub-section
+      currentSubSection = null;
+
+      // Check if user has this key
+      const userSection = userParsed[currentSection];
+      if (userSection && userSection[key] !== undefined && typeof userSection[key] !== "object") {
+        merged.push(`  ${key}: ${userSection[key]}`);
+        continue;
+      }
+      // New key — use template value
+      merged.push(line);
+      continue;
+    }
+
+    const deepMatch = line.match(/^    (\w[\w_-]*):\s*(.+)$/);
+    if (deepMatch && currentSection && currentSubSection) {
+      const key = deepMatch[1];
+      const userSection = userParsed[currentSection];
+      if (userSection && typeof userSection[currentSubSection] === "object") {
+        const userValue = userSection[currentSubSection][key];
+        if (userValue !== undefined) {
+          merged.push(`    ${key}: ${userValue}`);
+          continue;
+        }
+      }
+      // New key — use template value
+      merged.push(line);
+      continue;
+    }
+
+    merged.push(line);
+  }
+
+  return merged.join("\n");
+}
+
 function extractOrchestraSection(content) {
   const startIdx = content.indexOf(ORCHESTRA_SECTION_START);
   if (startIdx === -1) return null;
@@ -302,11 +419,14 @@ function run() {
       console.log("  [+] Restored knowledge.md");
     }
 
-    // Restore config.yml (user's customizations take priority)
+    // Merge config.yml: new template keys added, user values preserved
     if (hasConfig && fs.existsSync(configBackup)) {
-      fs.copyFileSync(configBackup, path.join(orchestraDest, "config.yml"));
+      const userConfig = fs.readFileSync(configBackup, "utf-8");
+      const templateConfig = fs.readFileSync(path.join(orchestraDest, "config.yml"), "utf-8");
+      const mergedConfig = mergeConfigYaml(userConfig, templateConfig);
+      fs.writeFileSync(path.join(orchestraDest, "config.yml"), mergedConfig);
       fs.unlinkSync(configBackup);
-      console.log("  [+] Restored config.yml (user customizations preserved)");
+      console.log("  [+] Merged config.yml (user values preserved, new keys added)");
     }
   } else {
     // ── Fresh install ──

package/bin/merge-config.test.js

@@ -0,0 +1,135 @@
+const { describe, it } = require("node:test");
+const assert = require("node:assert");
+const fs = require("fs");
+const path = require("path");
+
+// Extract mergeConfigYaml from index.js
+const src = fs.readFileSync(path.join(__dirname, "index.js"), "utf-8");
+const match = src.match(/function mergeConfigYaml\([\s\S]*?^}/m);
+eval(match[0]);
+
+const userConfig = `pipeline:
+  models:
+    quick: haiku
+    standard: sonnet
+    complex: opus
+  rfc_approval: skip
+  push_approval: auto
+  review: required
+  parallel: disabled
+
+thresholds:
+  re_review_lines: 50
+  phase_time_limit: 20
+  phase_tool_limit: 40
+  stuck_retry_limit: 5
+
+verification:
+  typecheck: "yarn tsc --noEmit"
+  test: "yarn test"
+  lint: "yarn lint"
+`;
+
+const templateConfig = `# Orchestra Configuration
+# Customize pipeline behavior, thresholds, and verification commands.
+
+pipeline:
+  # Model selection per phase complexity
+  models:
+    trivial: haiku
+    quick: sonnet
+    standard: sonnet
+    complex: opus
+  rfc_approval: required
+  push_approval: required
+  review: required
+  parallel: disabled
+  default_pipeline: full
+  default_complexity: standard
+  max_rfc_rounds: 3
+
+thresholds:
+  milestone_lock_timeout: 120
+  re_review_lines: 30
+  phase_time_limit: 15
+  phase_tool_limit: 40
+  stuck_retry_limit: 3
+
+verification:
+  typecheck: "npx tsc --noEmit"
+  test: "npm test"
+  lint: "npm run lint"
+`;
+
+describe("mergeConfigYaml", () => {
+  const result = mergeConfigYaml(userConfig, templateConfig);
+
+  describe("new template keys are added", () => {
+    it("adds trivial model tier", () => {
+      assert.ok(result.includes("trivial: haiku"));
+    });
+
+    it("adds default_pipeline", () => {
+      assert.ok(result.includes("default_pipeline: full"));
+    });
+
+    it("adds default_complexity", () => {
+      assert.ok(result.includes("default_complexity: standard"));
+    });
+
+    it("adds max_rfc_rounds", () => {
+      assert.ok(result.includes("max_rfc_rounds: 3"));
+    });
+
+    it("adds milestone_lock_timeout", () => {
+      assert.ok(result.includes("milestone_lock_timeout: 120"));
+    });
+  });
+
+  describe("user values are preserved", () => {
+    it("keeps user models.quick value", () => {
+      assert.ok(result.includes("quick: haiku"));
+    });
+
+    it("keeps user rfc_approval", () => {
+      assert.ok(result.includes("rfc_approval: skip"));
+    });
+
+    it("keeps user push_approval", () => {
+      assert.ok(result.includes("push_approval: auto"));
+    });
+
+    it("keeps user re_review_lines", () => {
+      assert.ok(result.includes("re_review_lines: 50"));
+    });
+
+    it("keeps user phase_time_limit", () => {
+      assert.ok(result.includes("phase_time_limit: 20"));
+    });
+
+    it("keeps user stuck_retry_limit", () => {
+      assert.ok(result.includes("stuck_retry_limit: 5"));
+    });
+
+    it("keeps user verification commands", () => {
+      assert.ok(result.includes('typecheck: "yarn tsc --noEmit"'));
+      assert.ok(result.includes('test: "yarn test"'));
+      assert.ok(result.includes('lint: "yarn lint"'));
+    });
+  });
+
+  describe("template structure is preserved", () => {
+    it("keeps comments from template", () => {
+      assert.ok(result.includes("# Orchestra Configuration"));
+      assert.ok(result.includes("# Model selection per phase complexity"));
+    });
+
+    it("maintains section order", () => {
+      const pipelineIdx = result.indexOf("pipeline:");
+      const thresholdsIdx = result.indexOf("thresholds:");
+      const verificationIdx = result.indexOf("verification:");
+      assert.ok(pipelineIdx < thresholdsIdx);
+      assert.ok(thresholdsIdx < verificationIdx);
+    });
+  });
+});

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@sulhadin/orchestrator",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-beta.9",
   "description": "AI Team Orchestration System — multi-role coordination for Claude Code",
   "bin": "bin/index.js",
   "scripts": {
+    "test": "node --test bin/**/*.test.js",
     "template": "node bin/build-template.js",
     "prepare": "husky"
   },

package/template/.claude/agents/conductor.md

@@ -43,13 +43,13 @@ Read `Complexity` from milestone.md + `pipeline` from config.yml:
 | `standard` | Phases → Review → Push |
 | `full` | Architect → Phases → Review → Push |
 
-Default: `full` if Complexity missing.
+Default: config.yml `pipeline.default_pipeline` (default `full`).
 
 ## Milestone Lock
 
 Before starting a milestone:
 1. Check milestone.md for `Locked-By` field
-2. If locked and < 2 hours old → skip this milestone
+2. If locked and < config.yml `thresholds.milestone_lock_timeout` minutes → skip this milestone
 3. If no lock or stale → write `Locked-By: {timestamp}`
 4. On completion or failure → remove `Locked-By`
 
@@ -64,7 +64,7 @@ For each phase:
 - Read phase file — extract role, skills, scope, acceptance criteria, depends_on
 - Check phase status — skip if `done`, resume if `in-progress`
 - Verify dependencies — all `depends_on` phases must be `done`
-- Select model: read `complexity` from phase file, map via config.yml `pipeline.models:` (default: `standard`)
+- Select model: read `complexity` from phase file (default: config.yml `pipeline.default_complexity`), map via `pipeline.models:`
 
 ### 2. Pre-read & Compose Prompt (Conductor does this)
 
@@ -184,7 +184,7 @@ Read gate behavior from config.yml:
 
 ## Rejection Flow
 
-- **RFC Rejected:** Ask feedback → architect revises → re-submit (max 3 rounds).
+- **RFC Rejected:** Ask feedback → architect revises → re-submit (max config.yml `pipeline.max_rfc_rounds`).
 - **Push Rejected:** Ask feedback → create fix phase → re-submit.
 
 ## Milestone Completion

package/template/.orchestra/config.yml

@@ -25,7 +25,19 @@ pipeline:
   # When enabled, phases with depends_on: [] run in parallel
   parallel: disabled
 
+  # Default pipeline when milestone Complexity is missing
+  default_pipeline: full  # quick | standard | full
+
+  # Default phase complexity when not set by PM
+  default_complexity: standard  # trivial | quick | standard | complex
+
+  # Max RFC rejection rounds before escalating to user
+  max_rfc_rounds: 3
+
 thresholds:
+  # Milestone lock timeout in minutes (stale locks are ignored)
+  milestone_lock_timeout: 120
+
   # Fix cycle: re-review if fix exceeds this many lines
   re_review_lines: 30