@ikunin/sprintpilot 1.0.5 → 2.0.5

package/bin/sprintpilot.js

@@ -53,6 +53,10 @@ async function main() {
       '--tools <list>',
       'Comma-separated tools (claude-code,cursor,windsurf,cline,roo,trae,kiro,gemini-cli,github-copilot,all)',
     )
+    .option(
+      '--profile <name>',
+      'Complexity profile: nano | small | medium | large | legacy (default: medium)',
+    )
     .option('--dry-run', 'Preview without making changes')
     .option('--force', 'Skip backup of existing skills')
     .option(

package/lib/commands/install.js

@@ -67,6 +67,8 @@ const PROJECT_ADDON_DIR_NAME = '_Sprintpilot';
 const DEFAULT_SESSION_STORY_LIMIT = 3;
 const DEFAULT_RETROSPECTIVE_MODE = 'auto';
 const RETROSPECTIVE_MODES = ['auto', 'stop', 'skip'];
+const COMPLEXITY_PROFILES = ['nano', 'small', 'medium', 'large', 'legacy'];
+const DEFAULT_COMPLEXITY_PROFILE = 'medium';
 const RUNTIME_RESOURCES = [
   'Sprintpilot.md',
   'manifest.yaml',
@@ -747,6 +749,134 @@ async function patchAutopilotConfig(projectRoot, { sessionStoryLimit, retrospect
   }
 }
 
+// Read the existing complexity_profile from autopilot/config.yaml so upgrades
+// preserve the user's v2 profile choice. Uses regex for the same reason
+// readExistingAutopilotConfig does — workflow.md's `{{variable}}` syntax
+// means a full YAML parse would mis-interpret the raw file.
+async function readExistingComplexityProfile(projectRoot, v1Snapshot) {
+  let raw = null;
+  const candidates = [
+    path.join(projectRoot, PROJECT_ADDON_DIR_NAME, 'modules', 'autopilot', 'config.yaml'),
+    path.join(projectRoot, V1_ADDON_DIR_NAME, 'modules', 'autopilot', 'config.yaml'),
+  ];
+  for (const file of candidates) {
+    if (!(await fs.pathExists(file))) continue;
+    try {
+      raw = await fs.readFile(file, 'utf8');
+      break;
+    } catch {
+      /* try next */
+    }
+  }
+  if (raw == null && v1Snapshot && Array.isArray(v1Snapshot.autopilot)) {
+    const entry = v1Snapshot.autopilot.find((f) => f.relPath === 'config.yaml');
+    if (entry && Buffer.isBuffer(entry.buffer)) {
+      try {
+        raw = entry.buffer.toString('utf8');
+      } catch {
+        /* unreadable */
+      }
+    }
+  }
+  if (raw == null) return null;
+  const commentTail = /[ \t]*(?:#.*)?$/.source;
+  const m = raw.match(
+    new RegExp(`^[ \\t]*complexity_profile:[ \\t]*["']?([a-zA-Z_-]+)["']?${commentTail}`, 'm'),
+  );
+  if (!m) return null;
+  if (!COMPLEXITY_PROFILES.includes(m[1])) return null;
+  return m[1];
+}
+
+async function patchComplexityProfile(projectRoot, profile) {
+  const file = path.join(
+    projectRoot,
+    PROJECT_ADDON_DIR_NAME,
+    'modules',
+    'autopilot',
+    'config.yaml',
+  );
+  if (!(await fs.pathExists(file))) return;
+  const original = await fs.readFile(file, 'utf8');
+  const updated = applyScalar(original, 'complexity_profile', profile);
+  if (updated !== original) {
+    await writeAtomic(file, updated);
+  }
+}
+
+// Validates --profile flag (if provided) and prompts interactively when
+// neither flag nor --yes is set. Returns the resolved profile string.
+// Backwards-compatible: if the user is upgrading and already has a profile
+// key, default to that; if absent, default to 'medium' (matches v1.0.5).
+async function resolveComplexityProfile({ projectRoot, yes, dryRun, options, v1Snapshot }) {
+  const existing = await readExistingComplexityProfile(projectRoot, v1Snapshot);
+
+  // Flag takes priority even in interactive mode so scripted runs are
+  // deterministic. Invalid flag = hard fail, not a silent default.
+  if (options && options.profile) {
+    if (!COMPLEXITY_PROFILES.includes(options.profile)) {
+      console.error(
+        pc.red(
+          `ERROR: unknown --profile '${options.profile}'. Valid: ${COMPLEXITY_PROFILES.join(', ')}`,
+        ),
+      );
+      process.exit(1);
+    }
+    return options.profile;
+  }
+
+  const fallback = existing || DEFAULT_COMPLEXITY_PROFILE;
+
+  if (yes) {
+    if (existing != null) {
+      console.log(pc.dim(`Preserving complexity_profile: ${existing}`));
+    } else {
+      console.log(
+        pc.dim(
+          `complexity_profile not set; defaulting to '${DEFAULT_COMPLEXITY_PROFILE}' (matches v1.0.5 behavior).`,
+        ),
+      );
+    }
+    return fallback;
+  }
+
+  if (dryRun) {
+    console.log(
+      pc.dim(`[DRY RUN] Would prompt for complexity_profile (current default: ${fallback})`),
+    );
+    return fallback;
+  }
+
+  const profile = await prompts.select({
+    message: 'Which complexity profile fits your project?',
+    options: [
+      {
+        value: 'nano',
+        label: 'nano   — toy / tutorial / learning, solo, small codebase',
+      },
+      {
+        value: 'small',
+        label: 'small  — MVP / internal tool / prototype, solo or 1–2 devs',
+      },
+      {
+        value: 'medium',
+        label: 'medium — team product with real users (recommended)',
+      },
+      {
+        value: 'large',
+        label: 'large  — production, compliance / uptime stakes',
+      },
+      {
+        value: 'legacy',
+        label: 'legacy — pre-v2 behavior (rollback escape hatch)',
+      },
+    ],
+    initialValue: fallback,
+  });
+
+  return profile;
+}
+
 async function resolveAutopilotSettings({ projectRoot, yes, dryRun, v1Snapshot }) {
   const existing = await readExistingAutopilotConfig(projectRoot, v1Snapshot);
   const defaultLimit = existing.sessionStoryLimit ?? DEFAULT_SESSION_STORY_LIMIT;
@@ -878,7 +1008,20 @@ async function runInstall(options = {}) {
     console.log('');
   }
 
-  // 2a. Autopilot configuration (prompt or preserve existing values).
+  // 2a. Complexity profile (Adaptive Process Scaling — v2.0.0).
+  // Selected before the autopilot scalar prompts because a non-default
+  // profile may influence those defaults in a future PR. For PR 1 the
+  // profile is written to config.yaml alongside the existing keys; it
+  // doesn't yet drive behavior — see docs/implementation-plan.md PR 4+.
+  const complexityProfile = await resolveComplexityProfile({
+    projectRoot,
+    yes,
+    dryRun,
+    options,
+    v1Snapshot: v1ConfigSnapshot,
+  });
+
+  // 2b. Autopilot configuration (prompt or preserve existing values).
   // These values are patched into modules/autopilot/config.yaml AFTER the
   // runtime copy — they're NOT threaded through `renderString`, because
   // workflow.md's `{{session_story_limit}}` / `{{retrospective_mode}}`
@@ -1114,6 +1257,11 @@ async function runInstall(options = {}) {
     //     reapply (which might have restored an older config.yaml without
     //     `retrospective_mode`). The user's prompted values always win.
     await patchAutopilotConfig(projectRoot, { sessionStoryLimit, retrospectiveMode });
+
+    // 6c. Persist the complexity_profile. Separate from patchAutopilotConfig
+    //     so the existing upgrade test coverage (readExistingAutopilotConfig /
+    //     patchAutopilotConfig) is unaffected by the new key.
+    await patchComplexityProfile(projectRoot, complexityProfile);
   }
 
   // 7. Verify git check-ignore
@@ -1166,6 +1314,9 @@ async function runInstall(options = {}) {
   // independent of the chosen values' widths (e.g. 2-digit limit, 4-char mode).
   const apKey = (k) => k.padEnd(31, ' ');
   const apVal = (v) => String(v).padEnd(6, ' ');
+  console.log(
+    `    ${apKey('autopilot.complexity_profile')}${apVal(complexityProfile)} Profile: nano | small | medium | large | legacy (rollback)`,
+  );
   console.log(
     `    ${apKey('autopilot.session_story_limit')}${apVal(sessionStoryLimit)} Stories to fully implement per run (0 = unlimited)`,
   );
@@ -1203,8 +1354,13 @@ module.exports = {
     readExistingAutopilotConfig,
     patchAutopilotConfig,
     applyScalar,
+    readExistingComplexityProfile,
+    patchComplexityProfile,
+    resolveComplexityProfile,
     RETROSPECTIVE_MODES,
     DEFAULT_SESSION_STORY_LIMIT,
     DEFAULT_RETROSPECTIVE_MODE,
+    COMPLEXITY_PROFILES,
+    DEFAULT_COMPLEXITY_PROFILE,
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikunin/sprintpilot",
-  "version": "1.0.5",
+  "version": "2.0.5",
   "description": "Sprintpilot — autopilot and multi-agent addon for BMad Method v6: git workflow, parallel agents, autonomous story execution",
   "license": "Apache-2.0",
   "repository": {