create-agdf 0.14.4 → 0.20.0

package/generated/plugins/agdf/runtime/create-agdf/lib/cli/parse-args.js

@@ -1,7 +1,7 @@
-import { resolve } from "node:path";
+import { isAbsolute, resolve } from "node:path";
 import process from "node:process";
 import { configuredLanguage, resolveLanguagePreference } from "./runtime-context.js";
-import { resolveCommand, supportedCommandNames } from "./command-registry.js";
+import { resolveCommand, supportedCommandNames, commandGroupRoutes } from "./command-registry.js";
 
 export class CliUsageError extends Error {
   constructor(message, { showUsage = false } = {}) {
@@ -12,6 +12,9 @@ export class CliUsageError extends Error {
   }
 }
 
+const STEP_FIELD_FLAGS = new Map(["title", "route", "reason", "evidence", "source", "covers", "decision", "result", "risk", "next"]
+  .map((name) => [`--${name}`, name]));
+
 function requiredValue(args, index, option) {
   const next = args[index + 1];
   if (!next) throw new CliUsageError(`Missing value for ${option}`);
@@ -20,19 +23,39 @@ function requiredValue(args, index, option) {
 
 export function parseArgs(argv, dependencies = {}) {
   const cwd = dependencies.cwd ?? process.cwd();
+  const workingDirectorySource = dependencies.cwdSource ?? "process_cwd";
+  if (!new Set(["npm_init_cwd", "process_cwd"]).has(workingDirectorySource)) {
+    throw new CliUsageError("Invalid invocation directory source.");
+  }
   const languagePreference = dependencies.resolveLanguagePreference ?? resolveLanguagePreference;
   const normalizeLanguage = dependencies.configuredLanguage ?? configuredLanguage;
   const args = [...argv];
   let target;
   let dir = ".";
+  let dirInput = ".";
   let force = false;
   let json = false;
   let verbose = false;
+  let guided = false;
+  let details = false;
   let statusCard = false;
   let approvalEnvelope = false;
   let language;
+  let languageExplicit = false;
   let dirExplicit = false;
   let surface = "generic";
+  let surfaceExplicit = false;
+  let skillId;
+  let intake = false;
+  let urAction;
+  let prdAction;
+  let sdAction;
+  let tpAction;
+  let intakeMode;
+  let continueDelivery = false;
+  let presentationId;
+  let operationId, assurance;
+  let revisionMode, sourceGate, previewDigest;
   let fixture;
   let persist = false;
   let model;
@@ -42,20 +65,47 @@ export function parseArgs(argv, dependencies = {}) {
   let generationTimeoutMs = 30000;
   let generationCostUnits = 5;
   let runId;
+  let gate;
+  let revisionId;
+  let response;
+  let contractModule, commandFile;
+  let runStep;
+  let recoveryAction;
+  let recoveryPreviewId;
+  let recoveryConfirmation;
+  const stepFields = {};
   let allActive = false;
   let scope;
   let confirm = false;
   let shared = false;
   let runtimeChecksDecision;
+  let acceptPluginCapabilities = false;
   let runtimeChecksAction;
+  let mcpAction;
+  let mcpScope;
+  let retireCockpit, restoreCockpit;
+  let setupRequest;
+  let controlDir;
+  let controlMigration;
+  let targetSource;
+  let primaryTarget;
+  let workingDirectory = cwd;
+  let workingDirectoryExplicit = false;
+  let targetChanged = false;
+  const targetCandidates = [];
+  const evidenceSources = [];
+  const flagCounts = new Map();
 
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
     if (!arg) continue;
+    if (arg.startsWith("--")) flagCounts.set(arg, (flagCounts.get(arg) ?? 0) + 1);
     if (arg === "--help" || arg === "-h") return { kind: "help" };
     if (arg === "--force") { force = true; continue; }
     if (arg === "--json") { json = true; continue; }
     if (arg === "--verbose") { verbose = true; continue; }
+    if (arg === "--guided") { guided = true; continue; }
+    if (arg === "--details") { details = true; continue; }
     if (arg === "--status-card") { statusCard = true; continue; }
     if (arg === "--approval-envelope") { approvalEnvelope = true; continue; }
     if (arg === "--persist") { persist = true; continue; }
@@ -63,6 +113,18 @@ export function parseArgs(argv, dependencies = {}) {
     if (arg === "--all-active") { allActive = true; continue; }
     if (arg === "--confirm") { confirm = true; continue; }
     if (arg === "--shared") { shared = true; continue; }
+    if (arg === "--accept-plugin-capabilities") { acceptPluginCapabilities = true; continue; }
+    if (arg === "--target-changed") { targetChanged = true; continue; }
+    if (arg === "--with-mcp") {
+      if (setupRequest === "plugin_only") throw new CliUsageError("--with-mcp and --plugin-only cannot be combined.");
+      setupRequest = "full";
+      continue;
+    }
+    if (arg === "--plugin-only") {
+      if (setupRequest === "full") throw new CliUsageError("--with-mcp and --plugin-only cannot be combined.");
+      setupRequest = "plugin_only";
+      continue;
+    }
 
     if (arg === "--runtime-checks") {
       const next = requiredValue(args, i, arg);
@@ -72,22 +134,148 @@ export function parseArgs(argv, dependencies = {}) {
       continue;
     }
 
+    if (arg === "--control-dir" || arg === "--control-migration") {
+      const next = requiredValue(args, i, arg);
+      if (arg === "--control-dir") {
+        if (!isAbsolute(next)) throw new CliUsageError("--control-dir requires an absolute repository path.");
+        controlDir = next;
+      } else {
+        if (!["inspect", "safe"].includes(next)) throw new CliUsageError("--control-migration must be inspect or safe.");
+        controlMigration = next;
+      }
+      i += 1;
+      continue;
+    }
+
     if (arg === "--run") {
       runId = requiredValue(args, i, arg);
       i += 1;
       continue;
     }
 
-    if (["--surface", "--scope", "--fixture", "--model", "--generator-model", "--max-generated-candidates", "--generation-timeout-ms", "--generation-cost-units"].includes(arg)) {
+    if (arg === "--step") {
+      runStep = requiredValue(args, i, arg);
+      i += 1;
+      continue;
+    }
+    if (arg === "--action") {
+      recoveryAction = requiredValue(args, i, arg);
+      i += 1;
+      continue;
+    }
+    if (arg === "--preview-id" || arg === "--recovery-confirmation") {
+      const value = requiredValue(args, i, arg);
+      if (arg === "--preview-id") recoveryPreviewId = value;
+      else recoveryConfirmation = value;
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--retire-cockpit' || arg === '--restore-cockpit') {
+      const value = requiredValue(args, i, arg);
+      if (retireCockpit !== undefined || restoreCockpit !== undefined) throw new CliUsageError('Cockpit transition selector may not repeat');
+      if (arg === '--retire-cockpit') retireCockpit = value; else restoreCockpit = value;
+      i += 1; continue;
+    }
+    if (STEP_FIELD_FLAGS.has(arg)) {
+      stepFields[STEP_FIELD_FLAGS.get(arg)] = requiredValue(args, i, arg);
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--command-file') {
+      if (commandFile !== undefined) throw new CliUsageError('--command-file may not repeat');
+      commandFile = resolve(cwd, requiredValue(args, i, arg)); i += 1; continue;
+    }
+    if (arg === "--module") {
+      contractModule = requiredValue(args, i, arg);
+      i += 1;
+      continue;
+    }
+
+    if (["--gate", "--revision", "--response"].includes(arg)) {
+      const next = requiredValue(args, i, arg);
+      if (arg === "--gate") gate = next;
+      else if (arg === "--revision") revisionId = next;
+      else response = next;
+      i += 1;
+      continue;
+    }
+
+    if (["--preview", "--apply", "--inspect", "--recover"].includes(arg)) {
+      if (revisionMode) throw new CliUsageError("run-revise modes are mutually exclusive and may not repeat");
+      revisionMode = arg.slice(2); continue;
+    }
+    if (arg === "--source-gate" || arg === "--preview-digest") {
+      const value = requiredValue(args, i, arg);
+      if (arg === "--source-gate") {
+        if (sourceGate !== undefined) throw new CliUsageError("--source-gate may not repeat");
+        sourceGate = value;
+      } else {
+        if (previewDigest !== undefined) throw new CliUsageError("--preview-digest may not repeat");
+        previewDigest = value;
+      }
+      i += 1; continue;
+    }
+    if (arg === "--operation" || arg === "--assurance") {
+      const value = requiredValue(args, i, arg);
+      if (arg === "--operation") {
+        if (operationId !== undefined) throw new CliUsageError("--operation may not repeat");
+        operationId = value;
+      }
+      else assurance = value;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--skill") {
+      skillId = requiredValue(args, i, arg);
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--intake-mode" || arg === "--ur-action" || arg === "--prd-action" || arg === "--sd-action" || arg === "--tp-action" || arg === "--presentation") {
+      const value = requiredValue(args, i, arg);
+      if (arg === "--intake-mode") intakeMode = value;
+      else if (arg === "--ur-action") urAction = value;
+      else if (arg === "--prd-action") prdAction = value;
+      else if (arg === "--sd-action") sdAction = value;
+      else if (arg === "--tp-action") tpAction = value;
+      else presentationId = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--continue-delivery") { continueDelivery = true; continue; }
+    if (arg === "--intake") {
+      intake = true;
+      continue;
+    }
+
+    if (["--target-source", "--primary-target", "--working-directory", "--target-candidate", "--evidence-source"].includes(arg)) {
+      const next = requiredValue(args, i, arg);
+      if (arg === "--target-source") targetSource = next;
+      else if (arg === "--primary-target") primaryTarget = next;
+      else if (arg === "--working-directory") { workingDirectory = next; workingDirectoryExplicit = true; }
+      else if (arg === "--target-candidate") targetCandidates.push(next);
+      else evidenceSources.push(next);
+      i += 1;
+      continue;
+    }
+
+    if (["--surface", "--scope", "--mcp-scope", "--fixture", "--model", "--generator-model", "--max-generated-candidates", "--generation-timeout-ms", "--generation-cost-units"].includes(arg)) {
       const next = requiredValue(args, i, arg);
       if (arg === "--surface") {
         if (!["codex", "claude", "copilot", "opencode", "generic"].includes(next)) {
           throw new CliUsageError("Unsupported surface. Use codex, claude, copilot, opencode or generic.");
         }
         surface = next;
+        surfaceExplicit = true;
       } else if (arg === "--scope") {
-        if (!["repository", "global"].includes(next)) throw new CliUsageError("Unsupported scope. Use repository or global.");
+        if (!["repository", "global", "project", "user"].includes(next)) throw new CliUsageError("Unsupported scope. Use repository, global, project or user.");
         scope = next;
+      } else if (arg === "--mcp-scope") {
+        if (!["project", "user"].includes(next)) throw new CliUsageError("Unsupported MCP scope. Use project or user.");
+        mcpScope = next;
       } else if (arg === "--fixture") fixture = next;
       else if (arg === "--model") model = next;
       else if (arg === "--generator-model") generatorModel = next;
@@ -110,12 +298,14 @@ export function parseArgs(argv, dependencies = {}) {
       const normalized = normalizeLanguage(next);
       if (!normalized) throw new CliUsageError("Invalid language tag. Use a BCP 47 tag such as de, en or fr-CA.");
       language = normalized;
+      languageExplicit = true;
       i += 1;
       continue;
     }
 
     if (arg === "--dir") {
-      dir = requiredValue(args, i, arg);
+      dirInput = requiredValue(args, i, arg);
+      dir = dirInput;
       dirExplicit = true;
       i += 1;
       continue;
@@ -136,41 +326,100 @@ export function parseArgs(argv, dependencies = {}) {
       runtimeChecksAction = arg;
       continue;
     }
+    if (!arg.startsWith("-") && target === "mcp" && !mcpAction) {
+      if (!["status", "enable", "disable"].includes(arg)) throw new CliUsageError("mcp action must be status, enable or disable.");
+      mcpAction = arg;
+      continue;
+    }
     throw new CliUsageError(`Unknown argument: ${arg}`);
   }
 
   if (!target || !resolveCommand(target)) {
     throw new CliUsageError(`Please choose one target: ${supportedCommandNames().join(", ")}.`, { showUsage: true });
   }
+  if (revisionMode && ["--dir", "--run", "--revision", "--operation", "--source-gate", "--evidence", "--preview-digest"].some(flag => flagCounts.get(flag) > 1)) {
+    throw new CliUsageError("Source revision identity and evidence flags may not repeat");
+  }
+  if ((retireCockpit !== undefined || restoreCockpit !== undefined)
+    && ['--dir', '--surface', '--scope', '--evidence'].some(flag => flagCounts.get(flag) > 1)) {
+    throw new CliUsageError('Cockpit transition identity and evidence flags may not repeat');
+  }
 
+  if (Object.hasOwn(commandGroupRoutes, target) && [...flagCounts.keys()].some(flag => !['--command-file', '--json'].includes(flag))) throw new CliUsageError('Bound command routes accept only --command-file and --json; no overriding envelope fields.');
   return {
     kind: "command",
     options: {
       target,
       dir: resolve(cwd, dir),
+      dirInput,
+      dirInputAbsolute: dirExplicit && isAbsolute(dirInput),
       force,
       json,
       verbose,
+      ...(guided ? { guided: true } : {}),
+      ...(details ? { details: true } : {}),
       statusCard,
       approvalEnvelope,
       dirExplicit,
       language: languagePreference(language),
+      languageExplicit,
       surface,
+      surfaceExplicit,
+      skillId,
+      intake,
+      intakeMode,
+    urAction,
+    prdAction,
+    sdAction,
+    tpAction,
+      continueDelivery,
+      presentationId,
+      ...(operationId !== undefined ? { operationId } : {}),
+      ...(assurance !== undefined ? { assurance } : {}),
+      ...(revisionMode !== undefined ? { revisionMode } : {}),
+      ...(sourceGate !== undefined ? { sourceGate } : {}),
+      ...(previewDigest !== undefined ? { previewDigest } : {}),
       fixture: fixture ? resolve(cwd, fixture) : null,
       persist,
       model,
       generateCandidates,
       runId,
+      gate,
+      revisionId,
+      response,
+      contractModule,
+      commandFile,
+      runStep,
+      recoveryAction,
+      recoveryPreviewId,
+      recoveryConfirmation,
+      stepFields,
       allActive,
       scope,
       confirm,
       shared,
       runtimeChecksDecision,
+      acceptPluginCapabilities,
       runtimeChecksAction: runtimeChecksAction ?? "status",
+      mcpAction,
+      mcpScope,
+      ...(retireCockpit !== undefined ? { retireCockpit } : {}),
+      ...(restoreCockpit !== undefined ? { restoreCockpit } : {}),
+      setupRequest,
+      controlDir,
+      controlMigration,
       generatorModel,
       maxGeneratedCandidates,
       generationTimeoutMs,
       generationCostUnits,
+      targetSource,
+      primaryTarget,
+      workingDirectory: isAbsolute(workingDirectory) ? workingDirectory : resolve(cwd, workingDirectory),
+      workingDirectorySource,
+      workingDirectoryExplicit,
+      targetChanged,
+      targetCandidates,
+      evidenceSources,
     },
   };
 }

package/generated/plugins/agdf/runtime/create-agdf/lib/cli/runtime-context.js

@@ -1,31 +1,18 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import process from "node:process";
 import {
   canonicalizeLanguageTag,
-  resolvePresentationLocale,
-} from "../interaction-presentation.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-export const packageRoot = resolve(__dirname, "../..");
-export const generatedRoot = join(packageRoot, "generated");
-
-const pluginDefinitionPath = join(generatedRoot, "plugins", "agdf", "meta", "agdf-plugin.definition.json");
-const interactionLocalesPath = join(generatedRoot, "plugins", "agdf", "meta", "agdf-interaction-locales.json");
-
-export const pluginDefinition = JSON.parse(readFileSync(pluginDefinitionPath, "utf8"));
-export const interactionLocales = JSON.parse(readFileSync(interactionLocalesPath, "utf8"));
-
-export function configuredLanguage(value) {
-  const normalized = canonicalizeLanguageTag(value);
-  if (!normalized) return "";
-  const language = normalized.split("-")[0];
-  if (interactionLocales.locales[normalized] || interactionLocales.locales[language]) {
-    return resolvePresentationLocale(interactionLocales, normalized);
-  }
-  return normalized;
+} from "#agdf-core/interaction-presentation.js";
+
+import { configuredLanguage, interactionLocales } from "../runtime/control-context.js";
+export { packageRoot, generatedRoot, pluginDefinition, interactionLocales, configuredLanguage, resolveConfiguredChatLanguage } from "../runtime/control-context.js";
+
+export function canonicalizeDetectedSystemLocale(value) {
+  if (typeof value !== "string") return "";
+  const candidate = value.trim().split(":", 1)[0];
+  if (!candidate || /^(?:C|POSIX)(?:\.|$)/iu.test(candidate)) return "";
+  const withoutModifier = candidate.split("@", 1)[0];
+  const withoutEncoding = withoutModifier.split(".", 1)[0];
+  return canonicalizeLanguageTag(withoutEncoding.replaceAll("_", "-"));
 }
 
 export function detectSystemLocale(env = process.env) {
@@ -51,7 +38,8 @@ export function resolveLanguagePreference(explicitLanguage, env = process.env) {
   }
 
   const detectedLocale = detectSystemLocale(env);
-  const detected = configuredLanguage(detectedLocale) || interactionLocales.fallbackLocale;
+  const detectedTag = canonicalizeDetectedSystemLocale(detectedLocale);
+  const detected = configuredLanguage(detectedTag) || "en";
   return {
     artifact_language: detected,
     chat_language: detected,
@@ -61,17 +49,6 @@ export function resolveLanguagePreference(explicitLanguage, env = process.env) {
   };
 }
 
-export function resolveConfiguredChatLanguage(targetDir) {
-  const configPath = join(targetDir, ".agdf", "control", "config.json");
-  if (!existsSync(configPath)) return interactionLocales.fallbackLocale;
-  try {
-    const config = JSON.parse(readFileSync(configPath, "utf8"));
-    return resolvePresentationLocale(interactionLocales, config.chat_language);
-  } catch {
-    return interactionLocales.fallbackLocale;
-  }
-}
-
 export function languageConfigContent(languagePreference) {
   return `${JSON.stringify({
     artifact_language: languagePreference.artifact_language,