@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-methodology-interaction-command.mjs

@@ -0,0 +1,147 @@
+import path from 'node:path';
+
+import {
+  normalizeProductMethodologyKind,
+  productMethodologyGateKinds,
+} from './runtime-product-methodology-gates.mjs';
+import { runProductMethodologyGateCommand } from './runtime-product-methodology-command.mjs';
+import {
+  deliveryMethodologyGateKinds,
+  normalizeDeliveryMethodologyKind,
+} from './runtime-delivery-methodology-gates.mjs';
+import { runDeliveryMethodologyGateCommand } from './runtime-delivery-methodology-command.mjs';
+import {
+  implementationMethodologyGateKinds,
+  normalizeImplementationMethodologyKind,
+} from './runtime-implementation-methodology-gates.mjs';
+import { runImplementationMethodologyGateCommand } from './runtime-implementation-methodology-command.mjs';
+import { printMethodology as printMethodologyPresentation } from './runtime-methodology-presentation.mjs';
+
+const methodologySurfaceNames = Object.freeze([
+  'runMethodology',
+]);
+
+export const runtimeMethodologyInteractionCommandOwner = Object.freeze({
+  owner: 'runtime-methodology-interaction-command',
+  domain: 'methodology',
+  layer: 'commandWrapper',
+  risk: 'medium',
+  migration_state: 'generic-wrapper-only',
+  behavior_change: false,
+  eager_import_behavior: 'unchanged',
+  dispatch_behavior: 'unchanged',
+  state_semantics: 'unchanged',
+  gate_dispatch_order: [
+    'product',
+    'delivery',
+    'implementation',
+    'generic-methodology',
+  ],
+  surface_names: methodologySurfaceNames,
+});
+
+export function runtimeMethodologyInteractionSurfaceNames() {
+  return [...methodologySurfaceNames];
+}
+
+export function createRuntimeMethodologyInteractionCommands(deps = {}) {
+  const {
+    ensureRoot,
+    writeJsonEnvelope,
+    printList,
+    workflowPresentation,
+    methodologyCoveragePresentation,
+    methodologyAuditEnvelope,
+    methodologyRouteEnvelope,
+    workflowReadinessEnvelope,
+    methodologyCoverageEnvelope,
+    methodologyEnvelope,
+    writeMethodologyGate,
+  } = deps;
+
+  function runMethodology(options) {
+    if (!options.methodologyCoverageMap && (options.write || options.scan || options.once || options.fromDispatch || options.dispatchEvent || options.actor || options.approval || options.run || options.autoRun || options.dispatch || options.dispatchIntent || options.preflight)) throw new Error('methodology supports catalog, route, readiness, gate, and read-only audit only');
+    ensureRoot(options.root);
+    const modes = [options.methodologyCatalog, options.methodologyRoute, options.methodologyReadiness, options.methodologyCoverageMap, options.methodologyGate, options.methodologyList, options.methodologyShow, options.methodologyVerify].filter(Boolean);
+    if (modes.length !== 1) {
+      const modeMessage = options.methodologyCoverageMap
+        ? 'methodology requires exactly one of --catalog, --route, --readiness, --coverage-map, --gate, --list, --show, or --verify'
+        : 'methodology requires exactly one of --catalog, --route, --readiness, --gate, --list, --show, or --verify';
+      throw new Error(modeMessage);
+    }
+    if (options.methodologyCatalog) {
+      if (options.confirm || options.dryRun) throw new Error('methodology catalog is read-only');
+      const envelope = methodologyAuditEnvelope(options.root, 'catalog');
+      if (options.json) writeJsonEnvelope('methodology', envelope);
+      else printMethodologyPresentation(envelope, { printList });
+      return;
+    }
+    if (options.methodologyRoute) {
+      if (options.confirm || options.dryRun) throw new Error('methodology route is read-only');
+      if (!options.methodologyIntent) throw new Error('methodology --route requires --intent <kind>');
+      const envelope = methodologyRouteEnvelope(options.root, options.methodologyIntent);
+      if (options.json) writeJsonEnvelope('methodology', envelope);
+      else printMethodologyPresentation(envelope, { printList });
+      return;
+    }
+    if (options.methodologyReadiness) {
+      if (options.confirm || options.dryRun || options.recoveryPreview || options.hooksPreview) throw new Error('methodology --readiness is read-only and does not accept --confirm, --preview, or --dry-run');
+      if (options.recoveryApply || options.mergeApply || options.platform || options.candidate || options.approvalPackage || options.sourceApplySandbox || options.sourceVerifyChange) throw new Error('methodology --readiness does not accept apply, platform, candidate, approval, or source mutation flags');
+      if (options.fromFile || options.fromReadiness || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0 || options.methodologyKind || options.methodologyFile) throw new Error('methodology --readiness does not accept concrete evidence, gate, or audit input files');
+      if (!options.methodologyIntent) throw new Error('methodology --readiness requires --intent <kind>');
+      const envelope = workflowReadinessEnvelope(options.root, { intent: options.methodologyIntent });
+      if (options.json) writeJsonEnvelope('methodology', envelope);
+      else workflowPresentation.printWorkflowReadiness(envelope);
+      return;
+    }
+    if (options.methodologyCoverageMap) {
+      if (options.confirm || options.dryRun || options.recoveryPreview || options.hooksPreview || options.write || options.scan || options.once || options.fromDispatch || options.dispatchEvent || options.actor || options.approval || options.run || options.autoRun || options.preflight || options.dispatch || options.dispatchIntent) throw new Error('methodology --coverage-map is read-only and report-only');
+      if (!options.fromSuperpowersRoot || !options.fromSuperpowers) throw new Error('methodology --coverage-map requires --from-superpowers-root <local-superpowers-root>');
+      if (options.fromFile || options.fromReadiness || options.fromFriction || options.fromTokenBudget || options.fromLearningPattern || options.fromConsole || options.fromRunbook || options.fromPlan || options.fromExecutablePlan || options.fromEvidence || options.methodologyIntent || options.methodologyKind || options.methodologyFile || options.learningObservationFiles.length > 0 || options.learningInstinctFile || options.tokenCompactionFiles.length > 0) throw new Error('methodology --coverage-map only accepts --from-superpowers-root, --json, and --root');
+      const envelope = methodologyCoverageEnvelope(options.root, options.fromSuperpowers);
+      if (options.json) writeJsonEnvelope('methodology', envelope);
+      else methodologyCoveragePresentation.printMethodologyCoverageMap(envelope);
+      return;
+    }
+    if (options.methodologyGate) {
+      if (!options.methodologyKind) throw new Error('methodology --gate requires --kind');
+      const normalizedProductKind = normalizeProductMethodologyKind(options.methodologyKind);
+      if (productMethodologyGateKinds.has(normalizedProductKind)) {
+        runProductMethodologyGateCommand({ writeJsonEnvelope, printList }, options);
+        return;
+      }
+      const normalizedDeliveryKind = normalizeDeliveryMethodologyKind(options.methodologyKind);
+      if (deliveryMethodologyGateKinds.has(normalizedDeliveryKind)) {
+        runDeliveryMethodologyGateCommand({ writeJsonEnvelope, printList }, options);
+        return;
+      }
+      const normalizedImplementationKind = normalizeImplementationMethodologyKind(options.methodologyKind);
+      if (implementationMethodologyGateKinds.has(normalizedImplementationKind)) {
+        runImplementationMethodologyGateCommand({ writeJsonEnvelope, printList }, options);
+        return;
+      }
+      if (options.fromFile) throw new Error('methodology --gate --from-file is only supported for product/UI, delivery, or implementation artifact gate kinds');
+      if (options.confirm && options.dryRun) throw new Error('methodology --gate accepts either preview or --confirm, not both');
+      const envelope = methodologyEnvelope(options.root, options.methodologyKind, { persist: options.confirm });
+      if (options.confirm) {
+        const file = writeMethodologyGate(options.root, envelope);
+        if (options.json) writeJsonEnvelope('methodology', { ...envelope, methodology_gate_file: path.basename(file) });
+        else printMethodologyPresentation(envelope, { printList, file });
+        return;
+      }
+      if (options.json) writeJsonEnvelope('methodology', envelope);
+      else printMethodologyPresentation(envelope, { printList });
+      return;
+    }
+    if (options.confirm || options.dryRun) throw new Error('methodology audit is read-only');
+    const mode = options.methodologyList ? 'list' : options.methodologyVerify ? 'verify' : 'show';
+    const envelope = methodologyAuditEnvelope(options.root, mode, options.methodologyFile);
+    if (options.json) writeJsonEnvelope('methodology', envelope);
+    else printMethodologyPresentation(envelope, { printList });
+  }
+
+  const commands = { runMethodology };
+  const missing = methodologySurfaceNames.filter((name) => typeof commands[name] !== 'function');
+  if (missing.length > 0) throw new Error(`methodology command owner missing surface(s): ${missing.join(', ')}`);
+  return Object.freeze(commands);
+}

package/tools/vibe-runtime/runtime-methodology-presentation.mjs

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import process from 'node:process';
+
+export function printMethodology(envelope, { printList, file = '' } = {}) {
+  console.log('Vibecoding Runtime Methodology Gate');
+  console.log(`Mode: ${envelope.mode.replace('methodology-', '')}`);
+  if (envelope.mode === 'methodology-catalog') {
+    console.log(`Gates: ${envelope.catalog.gates.length}; Digest: ${envelope.catalog.catalog_digest}`);
+    for (const gate of envelope.catalog.gates) console.log(`- ${gate.kind}: ${gate.skill}`);
+  } else if (envelope.mode === 'methodology-route') {
+    console.log(`Intent: ${envelope.methodology_route.intent}; First skill: ${envelope.methodology_route.first_skill}`);
+    console.log(`Workflow: ${envelope.methodology_route.selected_workflow.join(' -> ')}`);
+    console.log(`Gate kinds: ${envelope.methodology_route.gate_kinds.length > 0 ? envelope.methodology_route.gate_kinds.join(', ') : 'none'}`);
+    console.log(`Route digest: ${envelope.methodology_route.route_digest}`);
+  } else if (envelope.methodology_gate) {
+    console.log(`Kind: ${envelope.methodology_gate.kind}; Outcome: ${envelope.methodology_gate.outcome}; Blocked: ${envelope.methodology_gate.blocked_reasons.length}`);
+    if (file) console.log(`Methodology gate: ${path.relative(process.cwd(), file)}`);
+  } else if (envelope.mode === 'methodology-list') {
+    console.log(`Gates: ${envelope.summary.count}; Failed: ${envelope.summary.failed_count}`);
+    for (const gate of envelope.gates) console.log(`- ${gate.file}: ${gate.kind || 'unknown'}; outcome=${gate.outcome}; verification=${gate.ok ? 'passed' : 'failed'}`);
+  } else {
+    console.log(`File: ${envelope.summary.file}`);
+    console.log(`Kind: ${envelope.summary.kind}; Outcome: ${envelope.summary.outcome}; Blocked: ${envelope.summary.blocked_count}`);
+    console.log(`Verification: ${envelope.verification.ok ? 'passed' : 'failed'}`);
+    if (envelope.verification.failures.length > 0) printList('Verification failures', envelope.verification.failures);
+  }
+  if (envelope.quality?.length > 0) printList('Blocked reasons', envelope.quality);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function printProductMethodologyGate(envelope, { printList }) {
+  const gate = envelope.product_methodology_gate;
+  console.log('Vibecoding Runtime Product Methodology Gate');
+  console.log(`Stage: ${gate.stage}; Kind: ${gate.gate_kind}; Outcome: ${gate.gate_outcome}`);
+  console.log(`Artifact: ${gate.source_bindings.artifact_file}`);
+  console.log(`Source skill: expected=${gate.source_bindings.expected_source_skill}; declared=${gate.source_bindings.declared_source_skill}`);
+  console.log(`Next skill: ${gate.source_bindings.declared_next_skill || 'not declared'}`);
+  console.log(`Checks: ${gate.checks.filter((check) => check.pass).length}/${gate.checks.length} pass`);
+  if (gate.blocked_reasons.length > 0) printList('Blocked reasons', gate.blocked_reasons);
+  console.log('Boundary: writes=false; state_directory_created=false; methodology_gate_artifact=false; command_execution=false; check_execution=false; test_execution=false; browser_execution=false; skill_execution=false; workflow_execution=false; git=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+  console.log(`Gate digest: ${gate.gate_digest}`);
+  console.log(`Manual action: ${gate.next_manual_action}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function printDeliveryMethodologyGate(envelope, { printList }) {
+  const gate = envelope.delivery_methodology_gate;
+  console.log('Vibecoding Runtime Delivery Methodology Gate');
+  console.log(`Stage: ${gate.stage}; Kind: ${gate.gate_kind}; Outcome: ${gate.gate_outcome}`);
+  console.log(`Artifact: ${gate.source_bindings.artifact_file}`);
+  console.log(`Source skill: expected=${gate.source_bindings.expected_source_skill}; declared=${gate.source_bindings.declared_source_skill}`);
+  console.log(`Next skill: ${gate.source_bindings.declared_next_skill || 'not declared'}`);
+  console.log(`Checks: ${gate.checks.filter((check) => check.pass).length}/${gate.checks.length} pass`);
+  if (gate.summary?.link_count !== undefined) console.log(`Traceability links: ${gate.summary.link_count}`);
+  if (gate.blocked_reasons.length > 0) printList('Blocked reasons', gate.blocked_reasons);
+  console.log('Boundary: writes=false; state_directory_created=false; methodology_gate_artifact=false; command_execution=false; check_execution=false; test_execution=false; browser_execution=false; skill_execution=false; workflow_execution=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+  console.log(`Gate digest: ${gate.gate_digest}`);
+  console.log(`Manual action: ${gate.next_manual_action}`);
+  console.log(`Action: ${envelope.action}`);
+}
+
+export function printImplementationMethodologyGate(envelope, { printList }) {
+  const gate = envelope.implementation_methodology_gate;
+  console.log('Vibecoding Runtime Implementation Methodology Gate');
+  console.log(`Stage: ${gate.stage}; Kind: ${gate.gate_kind}; Outcome: ${gate.gate_outcome}`);
+  console.log(`Artifact: ${gate.source_bindings.artifact_file}`);
+  console.log(`Source skill: expected=${gate.source_bindings.expected_source_skill}; declared=${gate.source_bindings.declared_source_skill}`);
+  console.log(`Checks: ${gate.checks.filter((check) => check.pass).length}/${gate.checks.length} pass`);
+  console.log(`Implementation tasks: ${gate.summary.task_count}; required=${gate.summary.required_task_count}; test_required=${gate.summary.test_required_task_count}; high_risk=${gate.summary.high_risk_task_count}`);
+  if (gate.blocked_reasons.length > 0) printList('Blocked reasons', gate.blocked_reasons);
+  console.log('Boundary: writes=false; state_directory_created=false; methodology_gate_artifact=false; command_execution=false; check_execution=false; test_execution=false; browser_execution=false; skill_execution=false; workflow_execution=false; git=false; git_write=false; commit=false; pr=false; push=false; merge=false; platform_api=false; external_network=false; model_invocation=false; subagent=false; mcp=false; business_source_write=false');
+  console.log(`Gate digest: ${gate.gate_digest}`);
+  console.log(`Task registry digest: ${gate.source_bindings.implementation_task_registry_digest}`);
+  console.log(`Manual action: ${gate.next_manual_action}`);
+  console.log(`Action: ${envelope.action}`);
+}

package/tools/vibe-runtime/runtime-methodology-route-model.mjs

@@ -0,0 +1,93 @@
+import {
+  SKILL_ROUTE_REGISTRY_VERSION,
+  normalizeSkillRouteRegistryIntent,
+  skillRouteRegistryBoundaryAssertions,
+  skillRouteRegistryDefinitions,
+  skillRouteRegistryIntents,
+  skillRouteRegistrySnapshot,
+} from './runtime-skill-route-registry.mjs';
+
+export {
+  SKILL_ROUTE_REGISTRY_KIND,
+  SKILL_ROUTE_REGISTRY_STAGE,
+  SKILL_ROUTE_REGISTRY_VERSION,
+  normalizeSkillRouteRegistryIntent,
+  skillRouteRegistryBoundaryAssertions,
+  skillRouteRegistryDefinitions,
+  skillRouteRegistryIntents,
+  skillRouteRegistrySnapshot,
+} from './runtime-skill-route-registry.mjs';
+
+export function methodologyGateCatalog(digestObject) {
+  const gates = [
+    { kind: 'spec', skill: 'vibe-brainstorming', purpose: 'prove design-before-implementation discipline', required_criteria: ['goal', 'scope', 'non_goals_or_boundaries', 'options_or_tradeoffs', 'acceptance', 'handoff_to_plan'] },
+    { kind: 'plan', skill: 'vibe-writing-plans', purpose: 'prove file/interface/task/verification planning discipline', required_criteria: ['files', 'module_boundaries', 'data_or_state_flow', 'tasks', 'verification_commands_or_signals', 'risks'] },
+    { kind: 'tdd', skill: 'vibe-test-driven-development', purpose: 'prove red/green or verification-first discipline', required_criteria: ['behavior', 'red_signal', 'green_signal', 'fallback_verification', 'risk'] },
+    { kind: 'debug', skill: 'vibe-systematic-debugging', purpose: 'prove root-cause-before-fix discipline', required_criteria: ['reproduction', 'evidence', 'data_flow', 'single_hypothesis', 'hypothesis_test', 'root_cause_status'] },
+    { kind: 'review', skill: 'vibe-review', purpose: 'prove evidence-bound review and feedback decision discipline', required_criteria: ['finding_evidence', 'impact', 'severity', 'required_change', 'verification_after_fix'] },
+    { kind: 'completion', skill: 'vibe-verification-before-completion', purpose: 'prove evidence-before-claims discipline', required_criteria: ['claim', 'fresh_evidence', 'command_or_check', 'exit_status', 'key_output', 'coverage', 'gaps'] },
+    { kind: 'automation', skill: 'vibe-subagent-driven-development', purpose: 'Stage 40 Trace / Governance / Methodology Automation Expansion: prove hook/scheduler/subagent automation readiness without hidden execution', required_criteria: ['approved_dispatch', 'result_ingested', 'review_gate', 'bounded_hook_run', 'trace_or_governance'] },
+  ];
+  const catalog = { stage: 'Stage 32', version: 1, source: 'builtin-data-only', dynamic_code: false, remote_config: false, default_write: false, gates };
+  return { ...catalog, catalog_digest: digestObject(catalog) };
+}
+
+export function methodologyBoundaryAssertions() {
+  return {
+    platform_api: false,
+    external_delivery: false,
+    model_invocation: false,
+    git: false,
+    worktree: false,
+    subagent: false,
+    mcp: false,
+    business_source_write: false,
+    runtime_action: false,
+    auto_execution: false,
+    controlled_auto_execution: false,
+    skill_execution: false,
+    daemon: false,
+    dispatch_event_modified: false,
+    claim_modified: false,
+  };
+}
+
+export function methodologyRouteDefinitions() {
+  return skillRouteRegistryDefinitions().map((entry) => ({
+    intent: entry.intent,
+    aliases: [...entry.aliases],
+    workflow: [...entry.selected_workflow],
+    first_skill: entry.required_skill,
+    gate_kinds: [...entry.gate_kinds],
+    rationale: entry.rationale,
+    stop_condition: entry.stop_condition,
+    next_gate: entry.next_gate,
+    handoff_required: entry.handoff_required,
+    route_registry_id: entry.route_registry_id,
+    registry_version: SKILL_ROUTE_REGISTRY_VERSION,
+  }));
+}
+
+export function normalizeMethodologyIntent(intent) {
+  return normalizeSkillRouteRegistryIntent(intent);
+}
+
+export function methodologyRouteForIntent(intent) {
+  const normalized = normalizeMethodologyIntent(intent);
+  const definitions = methodologyRouteDefinitions();
+  const match = definitions.find((item) => item.intent === normalized || item.aliases.includes(normalized));
+  if (match) return match;
+  return {
+    intent: normalized || 'unknown',
+    aliases: [],
+    workflow: ['using-vibecoding', 'vibe-brainstorming'],
+    first_skill: 'using-vibecoding',
+    gate_kinds: ['spec'],
+    rationale: 'unknown or ambiguous intent should fall back to using-vibecoding and brainstorming before implementation',
+    stop_condition: 'ask the user for missing goal, scope, constraints, or acceptance criteria before editing',
+    next_gate: 'manual_workflow_judgment',
+    handoff_required: true,
+    route_registry_id: 'skill-route:unknown-fallback',
+    registry_version: SKILL_ROUTE_REGISTRY_VERSION,
+  };
+}