@specforge/cli 0.1.0

package/dist/cli/config/paths.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { CONFIG_FILES } from "./types.js";
+function getConfigPaths() {
+  const globalDir = getGlobalConfigDir();
+  return {
+    globalDir,
+    globalConfig: path.join(globalDir, CONFIG_FILES.GLOBAL_CONFIG),
+    projectConfig: path.resolve(CONFIG_FILES.PROJECT_CONFIG),
+    mcpConfig: path.resolve(CONFIG_FILES.MCP_CONFIG)
+  };
+}
+function getGlobalConfigDir() {
+  return path.join(os.homedir(), CONFIG_FILES.GLOBAL_DIR);
+}
+function getGlobalConfigPath() {
+  return path.join(getGlobalConfigDir(), CONFIG_FILES.GLOBAL_CONFIG);
+}
+function getProjectConfigPath() {
+  return path.resolve(CONFIG_FILES.PROJECT_CONFIG);
+}
+function getMcpConfigPath() {
+  return path.resolve(CONFIG_FILES.MCP_CONFIG);
+}
+function getPlanningSessionsRegistryPath(targetDir) {
+  const resolvedDir = targetDir ? path.resolve(targetDir) : process.cwd();
+  return path.join(resolvedDir, CONFIG_FILES.PROJECT_DIR, "planning-sessions.json");
+}
+function findProjectConfigPath(startDir) {
+  let currentDir = startDir ? path.resolve(startDir) : process.cwd();
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    const newConfigPath = path.join(currentDir, CONFIG_FILES.PROJECT_CONFIG);
+    if (fs.existsSync(newConfigPath)) {
+      return newConfigPath;
+    }
+    const legacyConfigPath = path.join(currentDir, CONFIG_FILES.LEGACY_PROJECT_CONFIG);
+    if (fs.existsSync(legacyConfigPath)) {
+      return legacyConfigPath;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  const rootNew = path.join(root, CONFIG_FILES.PROJECT_CONFIG);
+  if (fs.existsSync(rootNew)) {
+    return rootNew;
+  }
+  const rootLegacy = path.join(root, CONFIG_FILES.LEGACY_PROJECT_CONFIG);
+  if (fs.existsSync(rootLegacy)) {
+    return rootLegacy;
+  }
+  return null;
+}
+function findProjectRoot() {
+  const configPath = findProjectConfigPath();
+  if (!configPath) return null;
+  if (configPath.endsWith(CONFIG_FILES.PROJECT_CONFIG)) {
+    return path.dirname(path.dirname(configPath));
+  }
+  return path.dirname(configPath);
+}
+function isWithinGlobalDir(targetPath) {
+  const globalDir = getGlobalConfigDir();
+  const resolved = path.resolve(targetPath);
+  const relative = path.relative(globalDir, resolved);
+  return !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+export {
+  findProjectConfigPath,
+  findProjectRoot,
+  getConfigPaths,
+  getGlobalConfigDir,
+  getGlobalConfigPath,
+  getMcpConfigPath,
+  getPlanningSessionsRegistryPath,
+  getProjectConfigPath,
+  isWithinGlobalDir
+};
+//# sourceMappingURL=paths.js.map

package/dist/cli/config/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/config/paths.ts"],"sourcesContent":["/**\n * Config Paths Resolution\n *\n * Provides functions for resolving configuration file paths.\n * Handles both global (~/.specforge/) and project-level (.specforge.json) paths.\n */\n\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport os from 'node:os';\nimport { ConfigPaths, CONFIG_FILES } from './types.js';\n\n/**\n * Get all configuration file paths\n *\n * @returns ConfigPaths object with all resolved paths\n *\n * @example\n * ```typescript\n * const paths = getConfigPaths();\n * console.log(paths.globalDir);    // /home/user/.specforge\n * console.log(paths.globalConfig); // /home/user/.specforge/config.json\n * console.log(paths.projectConfig); // /current/dir/.specforge.json\n * ```\n */\nexport function getConfigPaths(): ConfigPaths {\n  const globalDir = getGlobalConfigDir();\n\n  return {\n    globalDir,\n    globalConfig: path.join(globalDir, CONFIG_FILES.GLOBAL_CONFIG),\n    projectConfig: path.resolve(CONFIG_FILES.PROJECT_CONFIG),\n    mcpConfig: path.resolve(CONFIG_FILES.MCP_CONFIG),\n  };\n}\n\n/**\n * Get the global configuration directory path\n *\n * Uses $HOME/.specforge on all platforms.\n * Does not create the directory - that's handled by the writer.\n *\n * @returns Absolute path to global config directory\n *\n * @example\n * ```typescript\n * const dir = getGlobalConfigDir();\n * // Linux/macOS: /home/user/.specforge\n * // Windows: C:\\Users\\user\\.specforge\n * ```\n */\nexport function getGlobalConfigDir(): string {\n  return path.join(os.homedir(), CONFIG_FILES.GLOBAL_DIR);\n}\n\n/**\n * Get the global configuration file path\n *\n * @returns Absolute path to ~/.specforge/config.json\n */\nexport function getGlobalConfigPath(): string {\n  return path.join(getGlobalConfigDir(), CONFIG_FILES.GLOBAL_CONFIG);\n}\n\n/**\n * Get the project configuration file path\n *\n * Resolves to .specforge.json in the current working directory.\n * Note: This returns the path in CWD only - for searching up the\n * directory tree, use findProjectConfigPath().\n *\n * @returns Absolute path to .specforge.json in current directory\n */\nexport function getProjectConfigPath(): string {\n  return path.resolve(CONFIG_FILES.PROJECT_CONFIG);\n}\n\n/**\n * Get the MCP configuration file path\n *\n * @returns Absolute path to .mcp.json in current directory\n */\nexport function getMcpConfigPath(): string {\n  return path.resolve(CONFIG_FILES.MCP_CONFIG);\n}\n\n/**\n * Get the planning-sessions registry path (M9.6 §2.6).\n *\n * Lives alongside config.json under the channel-aware project config dir\n * (`.specforge/planning-sessions.json` on stable, `.specforge-canary/...` on\n * canary — `CONFIG_FILES.PROJECT_DIR` flows from `CHANNEL.configDir`).\n *\n * @param targetDir - Project root (defaults to cwd)\n * @returns Absolute path to the planning-sessions registry file\n */\nexport function getPlanningSessionsRegistryPath(targetDir?: string): string {\n  const resolvedDir = targetDir ? path.resolve(targetDir) : process.cwd();\n  return path.join(resolvedDir, CONFIG_FILES.PROJECT_DIR, 'planning-sessions.json');\n}\n\n/**\n * Find project config by searching up the directory tree\n *\n * Starts from the current directory and walks up to the filesystem root,\n * looking for .specforge.json at each level.\n *\n * @param startDir - Directory to start searching from (defaults to cwd)\n * @returns Absolute path to .specforge.json if found, null otherwise\n *\n * @example\n * ```typescript\n * // Given: /home/user/projects/myapp/src/components\n * // With .specforge.json at /home/user/projects/myapp/.specforge.json\n *\n * const configPath = findProjectConfigPath();\n * // Returns: /home/user/projects/myapp/.specforge.json\n * ```\n */\nexport function findProjectConfigPath(startDir?: string): string | null {\n  let currentDir = startDir ? path.resolve(startDir) : process.cwd();\n  const root = path.parse(currentDir).root;\n\n  while (currentDir !== root) {\n    // Check new path first: .specforge/config.json\n    const newConfigPath = path.join(currentDir, CONFIG_FILES.PROJECT_CONFIG);\n    if (fs.existsSync(newConfigPath)) {\n      return newConfigPath;\n    }\n\n    // Fall back to legacy: .specforge.json\n    const legacyConfigPath = path.join(currentDir, CONFIG_FILES.LEGACY_PROJECT_CONFIG);\n    if (fs.existsSync(legacyConfigPath)) {\n      return legacyConfigPath;\n    }\n\n    currentDir = path.dirname(currentDir);\n  }\n\n  // Check root directory as well\n  const rootNew = path.join(root, CONFIG_FILES.PROJECT_CONFIG);\n  if (fs.existsSync(rootNew)) {\n    return rootNew;\n  }\n  const rootLegacy = path.join(root, CONFIG_FILES.LEGACY_PROJECT_CONFIG);\n  if (fs.existsSync(rootLegacy)) {\n    return rootLegacy;\n  }\n\n  return null;\n}\n\n/**\n * Get the directory containing the project config\n *\n * Useful for resolving relative paths from the project root.\n *\n * @returns Directory path if project config found, null otherwise\n */\nexport function findProjectRoot(): string | null {\n  const configPath = findProjectConfigPath();\n  if (!configPath) return null;\n\n  // If found at .specforge/config.json, root is two levels up\n  // If found at .specforge.json (legacy), root is one level up\n  if (configPath.endsWith(CONFIG_FILES.PROJECT_CONFIG)) {\n    return path.dirname(path.dirname(configPath));\n  }\n  return path.dirname(configPath);\n}\n\n/**\n * Check if a path is within the global config directory\n *\n * Security check to prevent path traversal attacks.\n *\n * @param targetPath - Path to check\n * @returns true if path is within ~/.specforge/\n */\nexport function isWithinGlobalDir(targetPath: string): boolean {\n  const globalDir = getGlobalConfigDir();\n  const resolved = path.resolve(targetPath);\n  const relative = path.relative(globalDir, resolved);\n\n  // If the relative path starts with '..' or is absolute, it's outside\n  return !relative.startsWith('..') && !path.isAbsolute(relative);\n}\n"],"mappings":"AAOA,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,OAAO,QAAQ;AACf,SAAsB,oBAAoB;AAenC,SAAS,iBAA8B;AAC5C,QAAM,YAAY,mBAAmB;AAErC,SAAO;AAAA,IACL;AAAA,IACA,cAAc,KAAK,KAAK,WAAW,aAAa,aAAa;AAAA,IAC7D,eAAe,KAAK,QAAQ,aAAa,cAAc;AAAA,IACvD,WAAW,KAAK,QAAQ,aAAa,UAAU;AAAA,EACjD;AACF;AAiBO,SAAS,qBAA6B;AAC3C,SAAO,KAAK,KAAK,GAAG,QAAQ,GAAG,aAAa,UAAU;AACxD;AAOO,SAAS,sBAA8B;AAC5C,SAAO,KAAK,KAAK,mBAAmB,GAAG,aAAa,aAAa;AACnE;AAWO,SAAS,uBAA+B;AAC7C,SAAO,KAAK,QAAQ,aAAa,cAAc;AACjD;AAOO,SAAS,mBAA2B;AACzC,SAAO,KAAK,QAAQ,aAAa,UAAU;AAC7C;AAYO,SAAS,gCAAgC,WAA4B;AAC1E,QAAM,cAAc,YAAY,KAAK,QAAQ,SAAS,IAAI,QAAQ,IAAI;AACtE,SAAO,KAAK,KAAK,aAAa,aAAa,aAAa,wBAAwB;AAClF;AAoBO,SAAS,sBAAsB,UAAkC;AACtE,MAAI,aAAa,WAAW,KAAK,QAAQ,QAAQ,IAAI,QAAQ,IAAI;AACjE,QAAM,OAAO,KAAK,MAAM,UAAU,EAAE;AAEpC,SAAO,eAAe,MAAM;AAE1B,UAAM,gBAAgB,KAAK,KAAK,YAAY,aAAa,cAAc;AACvE,QAAI,GAAG,WAAW,aAAa,GAAG;AAChC,aAAO;AAAA,IACT;AAGA,UAAM,mBAAmB,KAAK,KAAK,YAAY,aAAa,qBAAqB;AACjF,QAAI,GAAG,WAAW,gBAAgB,GAAG;AACnC,aAAO;AAAA,IACT;AAEA,iBAAa,KAAK,QAAQ,UAAU;AAAA,EACtC;AAGA,QAAM,UAAU,KAAK,KAAK,MAAM,aAAa,cAAc;AAC3D,MAAI,GAAG,WAAW,OAAO,GAAG;AAC1B,WAAO;AAAA,EACT;AACA,QAAM,aAAa,KAAK,KAAK,MAAM,aAAa,qBAAqB;AACrE,MAAI,GAAG,WAAW,UAAU,GAAG;AAC7B,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AASO,SAAS,kBAAiC;AAC/C,QAAM,aAAa,sBAAsB;AACzC,MAAI,CAAC,WAAY,QAAO;AAIxB,MAAI,WAAW,SAAS,aAAa,cAAc,GAAG;AACpD,WAAO,KAAK,QAAQ,KAAK,QAAQ,UAAU,CAAC;AAAA,EAC9C;AACA,SAAO,KAAK,QAAQ,UAAU;AAChC;AAUO,SAAS,kBAAkB,YAA6B;AAC7D,QAAM,YAAY,mBAAmB;AACrC,QAAM,WAAW,KAAK,QAAQ,UAAU;AACxC,QAAM,WAAW,KAAK,SAAS,WAAW,QAAQ;AAGlD,SAAO,CAAC,SAAS,WAAW,IAAI,KAAK,CAAC,KAAK,WAAW,QAAQ;AAChE;","names":[]}

package/dist/cli/config/planning-sessions-registry.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Planning Sessions Registry (M9.6 §2.6)
+ *
+ * Append-only record of every planning session the CLI has touched in a
+ * project, keyed by `specificationId`. Lives alongside `config.json` under the
+ * channel-aware project config dir (`.specforge/planning-sessions.json` on
+ * stable, `.specforge-canary/...` on canary).
+ *
+ * The local MCP server interpose maintains it:
+ * - `start_planning_session` success → {@link appendPlanningSessionRegistry}
+ *   records the new/resumed session id + start timestamp.
+ * - a `get_planning_status` response with `planningStatus: 'closed'` →
+ *   {@link markPlanningSessionRegistryCompleted} stamps `completedAt`.
+ *
+ * `complete_planning_session` does NOT touch the registry — CPS-success flips
+ * the session to `awaiting_human_review`, not closed.
+ */
+/** One registry entry, keyed by specificationId in the registry map. */
+export interface PlanningSessionRegistryEntry {
+    /** The planning session id returned by start_planning_session. */
+    planningSessionId: string;
+    /** ISO timestamp captured when the session was opened/resumed. */
+    startedAt: string;
+    /** ISO timestamp stamped when the session closed (cross_validation approved). */
+    completedAt?: string;
+}
+/** The on-disk registry shape: specificationId → entry. */
+export type PlanningSessionsRegistry = Record<string, PlanningSessionRegistryEntry>;
+/**
+ * Load the registry. Returns an empty map when the file is absent or
+ * unparseable (the registry is advisory bookkeeping — never throw on read).
+ */
+export declare function loadPlanningSessionsRegistry(targetDir?: string): PlanningSessionsRegistry;
+/**
+ * Record a newly started (or resumed) planning session for a spec.
+ * Overwrites any prior open entry for the same spec — there is at most one
+ * live planning session per spec (the lifecycle enforces this).
+ */
+export declare function appendPlanningSessionRegistry(entry: {
+    specificationId: string;
+    planningSessionId: string;
+    startedAt: string;
+}, targetDir?: string): void;
+/**
+ * Stamp `completedAt` on the open entry for a spec. No-op if there is no entry
+ * (e.g. registry was cleared or the session predates registry tracking).
+ */
+export declare function markPlanningSessionRegistryCompleted(entry: {
+    specificationId: string;
+    completedAt: string;
+}, targetDir?: string): void;
+//# sourceMappingURL=planning-sessions-registry.d.ts.map

package/dist/cli/config/planning-sessions-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planning-sessions-registry.d.ts","sourceRoot":"","sources":["../../../src/cli/config/planning-sessions-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,wEAAwE;AACxE,MAAM,WAAW,4BAA4B;IAC3C,kEAAkE;IAClE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,2DAA2D;AAC3D,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAC;AAEpF;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,wBAAwB,CAazF;AAWD;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAChF,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAON;AAED;;;GAGG;AACH,wBAAgB,oCAAoC,CAClD,KAAK,EAAE;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,EACvD,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAQN"}

package/dist/cli/config/planning-sessions-registry.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getPlanningSessionsRegistryPath } from "./paths.js";
+function loadPlanningSessionsRegistry(targetDir) {
+  const registryPath = getPlanningSessionsRegistryPath(targetDir);
+  if (!fs.existsSync(registryPath)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(registryPath, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeRegistry(registry, targetDir) {
+  const registryPath = getPlanningSessionsRegistryPath(targetDir);
+  const dir = path.dirname(registryPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2) + "\n");
+}
+function appendPlanningSessionRegistry(entry, targetDir) {
+  const registry = loadPlanningSessionsRegistry(targetDir);
+  registry[entry.specificationId] = {
+    planningSessionId: entry.planningSessionId,
+    startedAt: entry.startedAt
+  };
+  writeRegistry(registry, targetDir);
+}
+function markPlanningSessionRegistryCompleted(entry, targetDir) {
+  const registry = loadPlanningSessionsRegistry(targetDir);
+  const existing = registry[entry.specificationId];
+  if (!existing) {
+    return;
+  }
+  registry[entry.specificationId] = { ...existing, completedAt: entry.completedAt };
+  writeRegistry(registry, targetDir);
+}
+export {
+  appendPlanningSessionRegistry,
+  loadPlanningSessionsRegistry,
+  markPlanningSessionRegistryCompleted
+};
+//# sourceMappingURL=planning-sessions-registry.js.map

package/dist/cli/config/planning-sessions-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/config/planning-sessions-registry.ts"],"sourcesContent":["/**\n * Planning Sessions Registry (M9.6 §2.6)\n *\n * Append-only record of every planning session the CLI has touched in a\n * project, keyed by `specificationId`. Lives alongside `config.json` under the\n * channel-aware project config dir (`.specforge/planning-sessions.json` on\n * stable, `.specforge-canary/...` on canary).\n *\n * The local MCP server interpose maintains it:\n * - `start_planning_session` success → {@link appendPlanningSessionRegistry}\n *   records the new/resumed session id + start timestamp.\n * - a `get_planning_status` response with `planningStatus: 'closed'` →\n *   {@link markPlanningSessionRegistryCompleted} stamps `completedAt`.\n *\n * `complete_planning_session` does NOT touch the registry — CPS-success flips\n * the session to `awaiting_human_review`, not closed.\n */\n\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { getPlanningSessionsRegistryPath } from './paths.js';\n\n/** One registry entry, keyed by specificationId in the registry map. */\nexport interface PlanningSessionRegistryEntry {\n  /** The planning session id returned by start_planning_session. */\n  planningSessionId: string;\n  /** ISO timestamp captured when the session was opened/resumed. */\n  startedAt: string;\n  /** ISO timestamp stamped when the session closed (cross_validation approved). */\n  completedAt?: string;\n}\n\n/** The on-disk registry shape: specificationId → entry. */\nexport type PlanningSessionsRegistry = Record<string, PlanningSessionRegistryEntry>;\n\n/**\n * Load the registry. Returns an empty map when the file is absent or\n * unparseable (the registry is advisory bookkeeping — never throw on read).\n */\nexport function loadPlanningSessionsRegistry(targetDir?: string): PlanningSessionsRegistry {\n  const registryPath = getPlanningSessionsRegistryPath(targetDir);\n  if (!fs.existsSync(registryPath)) {\n    return {};\n  }\n  try {\n    const parsed = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));\n    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)\n      ? (parsed as PlanningSessionsRegistry)\n      : {};\n  } catch {\n    return {};\n  }\n}\n\nfunction writeRegistry(registry: PlanningSessionsRegistry, targetDir?: string): void {\n  const registryPath = getPlanningSessionsRegistryPath(targetDir);\n  const dir = path.dirname(registryPath);\n  if (!fs.existsSync(dir)) {\n    fs.mkdirSync(dir, { recursive: true });\n  }\n  fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\\n');\n}\n\n/**\n * Record a newly started (or resumed) planning session for a spec.\n * Overwrites any prior open entry for the same spec — there is at most one\n * live planning session per spec (the lifecycle enforces this).\n */\nexport function appendPlanningSessionRegistry(\n  entry: { specificationId: string; planningSessionId: string; startedAt: string },\n  targetDir?: string\n): void {\n  const registry = loadPlanningSessionsRegistry(targetDir);\n  registry[entry.specificationId] = {\n    planningSessionId: entry.planningSessionId,\n    startedAt: entry.startedAt,\n  };\n  writeRegistry(registry, targetDir);\n}\n\n/**\n * Stamp `completedAt` on the open entry for a spec. No-op if there is no entry\n * (e.g. registry was cleared or the session predates registry tracking).\n */\nexport function markPlanningSessionRegistryCompleted(\n  entry: { specificationId: string; completedAt: string },\n  targetDir?: string\n): void {\n  const registry = loadPlanningSessionsRegistry(targetDir);\n  const existing = registry[entry.specificationId];\n  if (!existing) {\n    return;\n  }\n  registry[entry.specificationId] = { ...existing, completedAt: entry.completedAt };\n  writeRegistry(registry, targetDir);\n}\n"],"mappings":"AAkBA,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,SAAS,uCAAuC;AAmBzC,SAAS,6BAA6B,WAA8C;AACzF,QAAM,eAAe,gCAAgC,SAAS;AAC9D,MAAI,CAAC,GAAG,WAAW,YAAY,GAAG;AAChC,WAAO,CAAC;AAAA,EACV;AACA,MAAI;AACF,UAAM,SAAS,KAAK,MAAM,GAAG,aAAa,cAAc,OAAO,CAAC;AAChE,WAAO,UAAU,OAAO,WAAW,YAAY,CAAC,MAAM,QAAQ,MAAM,IAC/D,SACD,CAAC;AAAA,EACP,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,SAAS,cAAc,UAAoC,WAA0B;AACnF,QAAM,eAAe,gCAAgC,SAAS;AAC9D,QAAM,MAAM,KAAK,QAAQ,YAAY;AACrC,MAAI,CAAC,GAAG,WAAW,GAAG,GAAG;AACvB,OAAG,UAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AAAA,EACvC;AACA,KAAG,cAAc,cAAc,KAAK,UAAU,UAAU,MAAM,CAAC,IAAI,IAAI;AACzE;AAOO,SAAS,8BACd,OACA,WACM;AACN,QAAM,WAAW,6BAA6B,SAAS;AACvD,WAAS,MAAM,eAAe,IAAI;AAAA,IAChC,mBAAmB,MAAM;AAAA,IACzB,WAAW,MAAM;AAAA,EACnB;AACA,gBAAc,UAAU,SAAS;AACnC;AAMO,SAAS,qCACd,OACA,WACM;AACN,QAAM,WAAW,6BAA6B,SAAS;AACvD,QAAM,WAAW,SAAS,MAAM,eAAe;AAC/C,MAAI,CAAC,UAAU;AACb;AAAA,EACF;AACA,WAAS,MAAM,eAAe,IAAI,EAAE,GAAG,UAAU,aAAa,MAAM,YAAY;AAChF,gBAAc,UAAU,SAAS;AACnC;","names":[]}

package/dist/cli/config/types.d.ts

@@ -0,0 +1,186 @@
+/**
+ * CLI Configuration Types
+ *
+ * Defines interfaces for global, project, and resolved configuration
+ * used throughout the CLI application.
+ */
+/**
+ * Output format options for CLI commands
+ */
+export type OutputFormat = 'json' | 'toon';
+/**
+ * Source tracking for configuration values
+ * Used for diagnostics and debugging (e.g., `specforge doctor`)
+ */
+export type ConfigSource = 'env' | 'global' | 'project' | 'default' | null;
+/**
+ * Global configuration stored in ~/.specforge/config.json
+ *
+ * This file contains user-level settings that apply across all projects.
+ * The API key is stored here for security (not in project files).
+ *
+ * @example
+ * ```json
+ * {
+ *   "apiKey": "sf_live_abc123...",
+ *   "mcpOutputFormat": "toon",
+ *   "defaultProjectId": "proj_xyz"
+ * }
+ * ```
+ */
+export interface GlobalConfig {
+    /** API key for SpecForge authentication (format: sf_live_*) */
+    apiKey?: string;
+    /**
+     * Wire encoding for the local MCP server's responses to the agent
+     * (TOON or JSON). NOT the human CLI output format — CLI commands render via
+     * their own per-command `--json`/`--toon` flags.
+     */
+    mcpOutputFormat?: OutputFormat;
+    /** Default project ID when not in a project directory */
+    defaultProjectId?: string;
+}
+/**
+ * Project configuration stored in .specforge.json
+ *
+ * This file is created in the project root when running `specforge init`.
+ * It links the local directory to a SpecForge project and specification.
+ *
+ * @example
+ * ```json
+ * {
+ *   "projectId": "proj_abc123",
+ *   "specificationId": "spec_xyz789",
+ *   "mcpOutputFormat": "json",
+ *   "autoSetContext": true
+ * }
+ * ```
+ */
+export interface ProjectConfig {
+    /** SpecForge project ID this directory is linked to */
+    projectId?: string;
+    /** Active specification ID for this project */
+    specificationId?: string;
+    /**
+     * Per-project override for the local MCP server's response wire encoding
+     * (TOON or JSON) sent to the agent. NOT the human CLI output format.
+     */
+    mcpOutputFormat?: OutputFormat;
+    /** Automatically set working context when CLI runs */
+    autoSetContext?: boolean;
+    /**
+     * Active planning session id for this spec (M9.6).
+     *
+     * Set after `start_planning_session` returns; auto-injected into
+     * `action_planning_session` / `complete_planning_session` by the local MCP
+     * server interpose. Cleared only when the session CLOSES (a
+     * `get_planning_status` response with `planningStatus: 'closed'`), NOT on
+     * `complete_planning_session` — CPS-success flips the session to
+     * `awaiting_human_review`, and the agent resumes under the same id across all
+     * phase handovers.
+     *
+     * Named `planningSessionId` (not a generic `sessionId`) because work/review
+     * lifecycles will persist their own session ids alongside this one.
+     */
+    planningSessionId?: string;
+}
+/**
+ * Resolved configuration merged from all sources
+ *
+ * This is the final configuration used by CLI commands after merging:
+ * - Environment variables (highest priority)
+ * - Project config (.specforge.json)
+ * - Global config (~/.specforge/config.json)
+ * - Default values (lowest priority)
+ */
+export interface ResolvedConfig {
+    /** API key for authentication (null if not authenticated) */
+    apiKey: string | null;
+    /** API endpoint URL */
+    apiUrl: string;
+    /** Resolved wire encoding for the local MCP server's responses to the agent */
+    mcpOutputFormat: OutputFormat;
+    /** Current project ID (null if not in project context) */
+    projectId: string | null;
+    /** Current specification ID (null if not set) */
+    specificationId: string | null;
+    /** Whether to auto-set working context */
+    autoSetContext: boolean;
+    /** Debug mode enabled */
+    debug: boolean;
+    /**
+     * Source tracking for each config value
+     * Useful for diagnostics and understanding where values come from
+     */
+    sources: ConfigSources;
+}
+/**
+ * Tracks the source of each resolved configuration value
+ */
+export interface ConfigSources {
+    /** Where the API key was loaded from */
+    apiKey: 'env' | 'global' | null;
+    /** Where the project ID was loaded from */
+    projectId: 'env' | 'project' | 'global' | null;
+    /** Where the specification ID was loaded from */
+    specificationId: 'project' | null;
+    /** Where the MCP output-format setting was loaded from */
+    mcpOutputFormat: 'env' | 'project' | 'global' | 'default';
+}
+/**
+ * Configuration file paths used by the CLI
+ */
+export interface ConfigPaths {
+    /** Global config directory (~/.specforge/) */
+    globalDir: string;
+    /** Global config file (~/.specforge/config.json) */
+    globalConfig: string;
+    /** Project config file (./.specforge.json) */
+    projectConfig: string;
+    /** MCP config file for Claude Code (./.mcp.json) */
+    mcpConfig: string;
+}
+/**
+ * Default configuration values
+ *
+ * `apiUrl` (MCP) flows from `CHANNEL` — stable channel hits the prod surfaces,
+ * canary hits the dev surfaces. The resolver in `transport/resolve-endpoint.ts`
+ * (Phase D) layers DNS-class fallback on top. Operators override via
+ * `SPECFORGE_API_URL` for smokes / self-hosting. The human CLI's `/cli` route is
+ * derived from `apiUrl` (same host) by `createCliClient`.
+ */
+export declare const CONFIG_DEFAULTS: {
+    readonly apiUrl: string;
+    readonly mcpOutputFormat: OutputFormat;
+    readonly autoSetContext: true;
+    readonly debug: false;
+};
+/**
+ * Environment variable names for configuration
+ */
+export declare const CONFIG_ENV_VARS: {
+    readonly API_KEY: "SPECFORGE_API_KEY";
+    readonly API_URL: "SPECFORGE_API_URL";
+    readonly MCP_OUTPUT_FORMAT: "SPECFORGE_MCP_OUTPUT_FORMAT";
+    readonly DEBUG: "SPECFORGE_DEBUG";
+};
+/**
+ * Configuration file names
+ *
+ * `GLOBAL_DIR`, `PROJECT_DIR`, and `PROJECT_CONFIG` flow from `CHANNEL.configDir`
+ * — `.specforge` on stable, `.specforge-canary` on canary. The two binaries
+ * coexist on one machine because their config dirs do not collide.
+ *
+ * `LEGACY_PROJECT_CONFIG` is the historical `.specforge.json` filename and
+ * stays fixed (not channel-aware) so the upgrade path keeps surfacing the
+ * breaking-change notice on every operation regardless of channel.
+ */
+export declare const CONFIG_FILES: {
+    readonly GLOBAL_DIR: string;
+    readonly GLOBAL_CONFIG: "config.json";
+    readonly PROJECT_DIR: string;
+    readonly PROJECT_CONFIG: `${string}/config.json`;
+    readonly LEGACY_PROJECT_CONFIG: ".specforge.json";
+    readonly MCP_CONFIG: ".mcp.json";
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/cli/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/config/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3C;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI,CAAC;AAE3E;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IACH,eAAe,CAAC,EAAE,YAAY,CAAC;IAE/B,yDAAyD;IACzD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,+CAA+C;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,eAAe,CAAC,EAAE,YAAY,CAAC;IAE/B,sDAAsD;IACtD,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtB,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IAEf,+EAA+E;IAC/E,eAAe,EAAE,YAAY,CAAC;IAE9B,0DAA0D;IAC1D,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB,iDAAiD;IACjD,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/B,0CAA0C;IAC1C,cAAc,EAAE,OAAO,CAAC;IAExB,yBAAyB;IACzB,KAAK,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,OAAO,EAAE,aAAa,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,wCAAwC;IACxC,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAC;IAEhC,2CAA2C;IAC3C,SAAS,EAAE,KAAK,GAAG,SAAS,GAAG,QAAQ,GAAG,IAAI,CAAC;IAE/C,iDAAiD;IACjD,eAAe,EAAE,SAAS,GAAG,IAAI,CAAC;IAElC,0DAA0D;IAC1D,eAAe,EAAE,KAAK,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;CAC3D;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAElB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IAErB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAC;IAEtB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;8BAEC,YAAY;;;CAG/B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;CAKlB,CAAC;AAEX;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;;;;;;;CAOf,CAAC"}

package/dist/cli/config/types.js

@@ -0,0 +1,27 @@
+import { CHANNEL } from "../../channel.js";
+const CONFIG_DEFAULTS = {
+  apiUrl: CHANNEL.endpoint.primary,
+  mcpOutputFormat: "toon",
+  autoSetContext: true,
+  debug: false
+};
+const CONFIG_ENV_VARS = {
+  API_KEY: "SPECFORGE_API_KEY",
+  API_URL: "SPECFORGE_API_URL",
+  MCP_OUTPUT_FORMAT: "SPECFORGE_MCP_OUTPUT_FORMAT",
+  DEBUG: "SPECFORGE_DEBUG"
+};
+const CONFIG_FILES = {
+  GLOBAL_DIR: CHANNEL.configDir,
+  GLOBAL_CONFIG: "config.json",
+  PROJECT_DIR: CHANNEL.configDir,
+  PROJECT_CONFIG: `${CHANNEL.configDir}/config.json`,
+  LEGACY_PROJECT_CONFIG: ".specforge.json",
+  MCP_CONFIG: ".mcp.json"
+};
+export {
+  CONFIG_DEFAULTS,
+  CONFIG_ENV_VARS,
+  CONFIG_FILES
+};
+//# sourceMappingURL=types.js.map

package/dist/cli/config/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/config/types.ts"],"sourcesContent":["/**\n * CLI Configuration Types\n *\n * Defines interfaces for global, project, and resolved configuration\n * used throughout the CLI application.\n */\n\nimport { CHANNEL } from '../../channel.js';\n\n/**\n * Output format options for CLI commands\n */\nexport type OutputFormat = 'json' | 'toon';\n\n/**\n * Source tracking for configuration values\n * Used for diagnostics and debugging (e.g., `specforge doctor`)\n */\nexport type ConfigSource = 'env' | 'global' | 'project' | 'default' | null;\n\n/**\n * Global configuration stored in ~/.specforge/config.json\n *\n * This file contains user-level settings that apply across all projects.\n * The API key is stored here for security (not in project files).\n *\n * @example\n * ```json\n * {\n *   \"apiKey\": \"sf_live_abc123...\",\n *   \"mcpOutputFormat\": \"toon\",\n *   \"defaultProjectId\": \"proj_xyz\"\n * }\n * ```\n */\nexport interface GlobalConfig {\n  /** API key for SpecForge authentication (format: sf_live_*) */\n  apiKey?: string;\n\n  /**\n   * Wire encoding for the local MCP server's responses to the agent\n   * (TOON or JSON). NOT the human CLI output format — CLI commands render via\n   * their own per-command `--json`/`--toon` flags.\n   */\n  mcpOutputFormat?: OutputFormat;\n\n  /** Default project ID when not in a project directory */\n  defaultProjectId?: string;\n}\n\n/**\n * Project configuration stored in .specforge.json\n *\n * This file is created in the project root when running `specforge init`.\n * It links the local directory to a SpecForge project and specification.\n *\n * @example\n * ```json\n * {\n *   \"projectId\": \"proj_abc123\",\n *   \"specificationId\": \"spec_xyz789\",\n *   \"mcpOutputFormat\": \"json\",\n *   \"autoSetContext\": true\n * }\n * ```\n */\nexport interface ProjectConfig {\n  /** SpecForge project ID this directory is linked to */\n  projectId?: string;\n\n  /** Active specification ID for this project */\n  specificationId?: string;\n\n  /**\n   * Per-project override for the local MCP server's response wire encoding\n   * (TOON or JSON) sent to the agent. NOT the human CLI output format.\n   */\n  mcpOutputFormat?: OutputFormat;\n\n  /** Automatically set working context when CLI runs */\n  autoSetContext?: boolean;\n\n  /**\n   * Active planning session id for this spec (M9.6).\n   *\n   * Set after `start_planning_session` returns; auto-injected into\n   * `action_planning_session` / `complete_planning_session` by the local MCP\n   * server interpose. Cleared only when the session CLOSES (a\n   * `get_planning_status` response with `planningStatus: 'closed'`), NOT on\n   * `complete_planning_session` — CPS-success flips the session to\n   * `awaiting_human_review`, and the agent resumes under the same id across all\n   * phase handovers.\n   *\n   * Named `planningSessionId` (not a generic `sessionId`) because work/review\n   * lifecycles will persist their own session ids alongside this one.\n   */\n  planningSessionId?: string;\n}\n\n/**\n * Resolved configuration merged from all sources\n *\n * This is the final configuration used by CLI commands after merging:\n * - Environment variables (highest priority)\n * - Project config (.specforge.json)\n * - Global config (~/.specforge/config.json)\n * - Default values (lowest priority)\n */\nexport interface ResolvedConfig {\n  /** API key for authentication (null if not authenticated) */\n  apiKey: string | null;\n\n  /** API endpoint URL */\n  apiUrl: string;\n\n  /** Resolved wire encoding for the local MCP server's responses to the agent */\n  mcpOutputFormat: OutputFormat;\n\n  /** Current project ID (null if not in project context) */\n  projectId: string | null;\n\n  /** Current specification ID (null if not set) */\n  specificationId: string | null;\n\n  /** Whether to auto-set working context */\n  autoSetContext: boolean;\n\n  /** Debug mode enabled */\n  debug: boolean;\n\n  /**\n   * Source tracking for each config value\n   * Useful for diagnostics and understanding where values come from\n   */\n  sources: ConfigSources;\n}\n\n/**\n * Tracks the source of each resolved configuration value\n */\nexport interface ConfigSources {\n  /** Where the API key was loaded from */\n  apiKey: 'env' | 'global' | null;\n\n  /** Where the project ID was loaded from */\n  projectId: 'env' | 'project' | 'global' | null;\n\n  /** Where the specification ID was loaded from */\n  specificationId: 'project' | null;\n\n  /** Where the MCP output-format setting was loaded from */\n  mcpOutputFormat: 'env' | 'project' | 'global' | 'default';\n}\n\n/**\n * Configuration file paths used by the CLI\n */\nexport interface ConfigPaths {\n  /** Global config directory (~/.specforge/) */\n  globalDir: string;\n\n  /** Global config file (~/.specforge/config.json) */\n  globalConfig: string;\n\n  /** Project config file (./.specforge.json) */\n  projectConfig: string;\n\n  /** MCP config file for Claude Code (./.mcp.json) */\n  mcpConfig: string;\n}\n\n/**\n * Default configuration values\n *\n * `apiUrl` (MCP) flows from `CHANNEL` — stable channel hits the prod surfaces,\n * canary hits the dev surfaces. The resolver in `transport/resolve-endpoint.ts`\n * (Phase D) layers DNS-class fallback on top. Operators override via\n * `SPECFORGE_API_URL` for smokes / self-hosting. The human CLI's `/cli` route is\n * derived from `apiUrl` (same host) by `createCliClient`.\n */\nexport const CONFIG_DEFAULTS = {\n  apiUrl: CHANNEL.endpoint.primary,\n  mcpOutputFormat: 'toon' as OutputFormat,\n  autoSetContext: true,\n  debug: false,\n} as const;\n\n/**\n * Environment variable names for configuration\n */\nexport const CONFIG_ENV_VARS = {\n  API_KEY: 'SPECFORGE_API_KEY',\n  API_URL: 'SPECFORGE_API_URL',\n  MCP_OUTPUT_FORMAT: 'SPECFORGE_MCP_OUTPUT_FORMAT',\n  DEBUG: 'SPECFORGE_DEBUG',\n} as const;\n\n/**\n * Configuration file names\n *\n * `GLOBAL_DIR`, `PROJECT_DIR`, and `PROJECT_CONFIG` flow from `CHANNEL.configDir`\n * — `.specforge` on stable, `.specforge-canary` on canary. The two binaries\n * coexist on one machine because their config dirs do not collide.\n *\n * `LEGACY_PROJECT_CONFIG` is the historical `.specforge.json` filename and\n * stays fixed (not channel-aware) so the upgrade path keeps surfacing the\n * breaking-change notice on every operation regardless of channel.\n */\nexport const CONFIG_FILES = {\n  GLOBAL_DIR: CHANNEL.configDir,\n  GLOBAL_CONFIG: 'config.json',\n  PROJECT_DIR: CHANNEL.configDir,\n  PROJECT_CONFIG: `${CHANNEL.configDir}/config.json`,\n  LEGACY_PROJECT_CONFIG: '.specforge.json',\n  MCP_CONFIG: '.mcp.json',\n} as const;\n"],"mappings":"AAOA,SAAS,eAAe;AA6KjB,MAAM,kBAAkB;AAAA,EAC7B,QAAQ,QAAQ,SAAS;AAAA,EACzB,iBAAiB;AAAA,EACjB,gBAAgB;AAAA,EAChB,OAAO;AACT;AAKO,MAAM,kBAAkB;AAAA,EAC7B,SAAS;AAAA,EACT,SAAS;AAAA,EACT,mBAAmB;AAAA,EACnB,OAAO;AACT;AAaO,MAAM,eAAe;AAAA,EAC1B,YAAY,QAAQ;AAAA,EACpB,eAAe;AAAA,EACf,aAAa,QAAQ;AAAA,EACrB,gBAAgB,GAAG,QAAQ,SAAS;AAAA,EACpC,uBAAuB;AAAA,EACvB,YAAY;AACd;","names":[]}

package/dist/cli/config/validation.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Config Schema Validation
+ *
+ * Validates the extended .specforge/config.json configuration schema.
+ * Each section is validated independently — absent sections are
+ * considered valid (all sections are optional).
+ *
+ * Uses manual validation (no external libs) to match existing patterns.
+ */
+/**
+ * A single validation error with field path and expected values.
+ */
+export interface ValidationError {
+    /** Dot-separated field path (e.g., "agentTeams.strategy") */
+    field: string;
+    /** Human-readable error message including expected values */
+    message: string;
+    /** The actual value that failed validation */
+    value: unknown;
+}
+/**
+ * Result of a validation operation.
+ */
+export interface ValidationResult {
+    /** Whether all validations passed */
+    valid: boolean;
+    /** List of validation errors (empty when valid) */
+    errors: ValidationError[];
+}
+/**
+ * Validate the `agentTeams` config section (v2.0.0).
+ *
+ * Returns valid:true if the section is absent/undefined.
+ * Only validates v2.0.0 fields. Deprecated fields are silently ignored.
+ */
+export declare function validateAgentTeamsConfig(config: unknown): ValidationResult;
+/**
+ * Validate the `activeSpecification` config section.
+ *
+ * Returns valid:true if the section is absent/undefined.
+ * When present, `id`, `title`, and `activatedAt` are required.
+ */
+export declare function validateActiveSpecification(config: unknown): ValidationResult;
+/**
+ * Validate the entire .specforge/config.json for Agent Teams sections.
+ *
+ * Orchestrates sub-validators and aggregates all errors.
+ * Only validates the Agent Teams sections — existing ProjectConfig
+ * fields are validated elsewhere.
+ *
+ * @param config - Raw parsed JSON object from .specforge/config.json
+ * @returns Combined validation result from all sections
+ */
+export declare function validateSpecforgeJson(config: unknown): ValidationResult;
+/**
+ * Format validation errors into human-readable lines.
+ *
+ * @param errors - Array of validation errors
+ * @returns Formatted error strings, one per line
+ */
+export declare function formatValidationErrors(errors: ValidationError[]): string[];
+//# sourceMappingURL=validation.d.ts.map

package/dist/cli/config/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/cli/config/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,mDAAmD;IACnD,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AA2DD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CA2C1E;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CA0C7E;AAMD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAgBvE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,EAAE,CAK1E"}

package/dist/cli/config/validation.js

@@ -0,0 +1,133 @@
+const ALLOWED_STRATEGIES = ["auto", "single", "parallel", "phased"];
+function err(field, message, value) {
+  return { field, message, value };
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function oneOf(field, value, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    return err(field, `Must be one of: ${allowed.join(", ")}`, value);
+  }
+  return null;
+}
+function numberInRange(field, value, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    return err(field, `Must be a number between ${min} and ${max}`, value);
+  }
+  return null;
+}
+function mustBeBoolean(field, value) {
+  if (typeof value !== "boolean") {
+    return err(field, "Must be a boolean", value);
+  }
+  return null;
+}
+function mustBeString(field, value) {
+  if (typeof value !== "string") {
+    return err(field, "Must be a string", value);
+  }
+  return null;
+}
+function mustBeNonEmptyString(field, value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return err(field, "Must be a non-empty string", value);
+  }
+  return null;
+}
+function validateAgentTeamsConfig(config) {
+  if (config === void 0 || config === null) {
+    return { valid: true, errors: [] };
+  }
+  const errors = [];
+  const prefix = "agentTeams";
+  if (!isObject(config)) {
+    return { valid: false, errors: [err(prefix, "Must be an object", config)] };
+  }
+  if ("enabled" in config && config.enabled !== void 0) {
+    const e = mustBeBoolean(`${prefix}.enabled`, config.enabled);
+    if (e) errors.push(e);
+  }
+  if ("strategy" in config && config.strategy !== void 0) {
+    const e = oneOf(`${prefix}.strategy`, config.strategy, ALLOWED_STRATEGIES);
+    if (e) errors.push(e);
+  }
+  if ("maxTicketsPerTeam" in config && config.maxTicketsPerTeam !== void 0) {
+    const e = numberInRange(`${prefix}.maxTicketsPerTeam`, config.maxTicketsPerTeam, 1, 20);
+    if (e) errors.push(e);
+  }
+  if ("maxParallelEpics" in config && config.maxParallelEpics !== void 0) {
+    const e = numberInRange(`${prefix}.maxParallelEpics`, config.maxParallelEpics, 1, 10);
+    if (e) errors.push(e);
+  }
+  if ("branchPrefix" in config && config.branchPrefix !== void 0) {
+    const e = mustBeString(`${prefix}.branchPrefix`, config.branchPrefix);
+    if (e) errors.push(e);
+  }
+  if ("timeoutMinutes" in config && config.timeoutMinutes !== void 0) {
+    const e = numberInRange(`${prefix}.timeoutMinutes`, config.timeoutMinutes, 5, 60);
+    if (e) errors.push(e);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateActiveSpecification(config) {
+  if (config === void 0 || config === null) {
+    return { valid: true, errors: [] };
+  }
+  const errors = [];
+  const prefix = "activeSpecification";
+  if (!isObject(config)) {
+    return { valid: false, errors: [err(prefix, "Must be an object", config)] };
+  }
+  if (!("id" in config) || config.id === void 0) {
+    errors.push(err(`${prefix}.id`, "Required field is missing", void 0));
+  } else {
+    const e = mustBeNonEmptyString(`${prefix}.id`, config.id);
+    if (e) errors.push(e);
+  }
+  if (!("title" in config) || config.title === void 0) {
+    errors.push(err(`${prefix}.title`, "Required field is missing", void 0));
+  } else {
+    const e = mustBeNonEmptyString(`${prefix}.title`, config.title);
+    if (e) {
+      errors.push(e);
+    } else if (typeof config.title === "string" && config.title.length > 200) {
+      errors.push(err(`${prefix}.title`, "Must be at most 200 characters", config.title));
+    }
+  }
+  if (!("activatedAt" in config) || config.activatedAt === void 0) {
+    errors.push(err(`${prefix}.activatedAt`, "Required field is missing", void 0));
+  } else if (typeof config.activatedAt !== "string") {
+    errors.push(err(`${prefix}.activatedAt`, "Must be a string", config.activatedAt));
+  } else if (isNaN(Date.parse(config.activatedAt))) {
+    errors.push(err(`${prefix}.activatedAt`, "Must be a valid ISO 8601 date string", config.activatedAt));
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateSpecforgeJson(config) {
+  if (config === void 0 || config === null) {
+    return { valid: true, errors: [] };
+  }
+  if (!isObject(config)) {
+    return { valid: false, errors: [err("config", "Must be an object", config)] };
+  }
+  const results = [
+    validateAgentTeamsConfig(config.agentTeams),
+    validateActiveSpecification(config.activeSpecification)
+  ];
+  const errors = results.flatMap((r) => r.errors);
+  return { valid: errors.length === 0, errors };
+}
+function formatValidationErrors(errors) {
+  return errors.map((e) => {
+    const valueStr = e.value === void 0 ? "undefined" : JSON.stringify(e.value);
+    return `  ${e.field}: ${e.message} (got ${valueStr})`;
+  });
+}
+export {
+  formatValidationErrors,
+  validateActiveSpecification,
+  validateAgentTeamsConfig,
+  validateSpecforgeJson
+};
+//# sourceMappingURL=validation.js.map