@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-test-run-command.mjs

@@ -0,0 +1,108 @@
+import { runtimeTestEvidenceEnvelope } from './runtime-test-evidence-model.mjs';
+
+const testRunSurfaceContract = 'runtime-cli-usage';
+
+const testProfiles = Object.freeze({
+  'runtime-test-evidence-syntax': Object.freeze({
+    id: 'runtime-test-evidence-syntax',
+    command: 'node --check tools/vibe-runtime/runtime-test-evidence-model.mjs',
+    argv: ['node', '--check', 'tools/vibe-runtime/runtime-test-evidence-model.mjs'],
+    timeout_ms: 20_000,
+    task_refs: ['auto-test-run'],
+    scenario_refs: ['p4:runtime-test-evidence-syntax'],
+  }),
+  'runtime-check': Object.freeze({
+    id: 'runtime-check',
+    command: 'node tools/vibe-runtime-check/index.mjs --root .',
+    argv: ['node', 'tools/vibe-runtime-check/index.mjs', '--root', '.'],
+    timeout_ms: 120_000,
+    task_refs: ['auto-test-run'],
+    scenario_refs: ['p4:runtime-check'],
+  }),
+  'npm-check': Object.freeze({
+    id: 'npm-check',
+    command: 'npm run check',
+    argv: ['npm', 'run', 'check'],
+    timeout_ms: 180_000,
+    task_refs: ['auto-test-run'],
+    scenario_refs: ['p4:npm-check'],
+  }),
+});
+
+const blockedTestControls = [
+  'dryRun',
+  'write',
+  'autoRun',
+  'scan',
+  'once',
+  'preflight',
+  'dispatch',
+  'dispatchIntent',
+  'candidate',
+  'approvalPackage',
+];
+
+export function runtimeTestRunProfiles() {
+  return Object.values(testProfiles).map((profile) => ({
+    id: profile.id,
+    command: profile.command,
+    timeout_ms: profile.timeout_ms,
+    task_refs: profile.task_refs,
+    scenario_refs: profile.scenario_refs,
+    contract_sync: testRunSurfaceContract,
+  }));
+}
+
+export function runTestRunCommand(deps, options) {
+  deps.ensureRoot(options.root);
+  assertTestRunOptions(options);
+  const profile = testProfiles[options.profile];
+  const result = runProfile(deps, options.root, profile);
+  const evidence = runtimeTestEvidenceEnvelope({ profile, result });
+  if (options.json) deps.emitJson('tests', evidence);
+  else printTestEvidence(evidence);
+}
+
+function assertTestRunOptions(options) {
+  if (!options.run) throw new Error('tests requires --run');
+  if (!options.confirm) throw new Error('tests --run requires --confirm');
+  if (!options.profile) throw new Error('tests --run requires --profile <profile>');
+  if (!testProfiles[options.profile]) throw new Error(`tests --run profile is not allowlisted: ${options.profile}`);
+  if (blockedTestControls.some((key) => options[key])) throw new Error('tests --run only accepts --profile, --confirm, --json, and --root');
+  if (options.fromFile || options.fromPlan || options.fromEvidence || options.approval || options.task || options.actor || options.reason) throw new Error('tests --run only accepts --profile, --confirm, --json, and --root');
+}
+
+function runProfile(deps, root, profile) {
+  const started = Date.now();
+  const [command, ...args] = profile.argv;
+  const result = deps.spawnSync(command, args, {
+    cwd: root,
+    encoding: 'utf8',
+    windowsHide: true,
+    shell: false,
+    timeout: profile.timeout_ms,
+    maxBuffer: 1024 * 1024 * 8,
+  });
+  const completed = Date.now();
+  const timeoutStderr = result.error?.code === 'ETIMEDOUT' ? `\nTimed out after ${profile.timeout_ms}ms` : '';
+  return {
+    exit_code: Number.isInteger(result.status) ? result.status : 1,
+    stdout: result.stdout || '',
+    stderr: `${result.stderr || ''}${result.error?.message || ''}${timeoutStderr}`,
+    started_at: new Date(started).toISOString(),
+    completed_at: new Date(completed).toISOString(),
+    duration_ms: completed - started,
+  };
+}
+
+function printTestEvidence(evidence) {
+  const run = evidence.runs?.[0] || {};
+  console.log('Vibecoding Runtime Test Evidence');
+  console.log(`Profile: ${evidence.runtime_test_run?.profile_id || run.id || 'unknown'}`);
+  console.log(`Status: ${evidence.runtime_test_run?.status || run.status}; exit_code=${run.exit_code}`);
+  console.log(`Command: ${run.command}`);
+  console.log(`Output digest: ${run.output_digest}`);
+  console.log(`Boundary: allowlisted_profile=${evidence.allowlisted_profile}; confirmation_received=${evidence.confirmation_received}; git_write=${evidence.git_write}; worktree_write=${evidence.worktree_write}`);
+  console.log(`Evidence digest: ${evidence.test_evidence_digest}`);
+  console.log(`Manual action: ${evidence.manual_action}`);
+}

package/tools/vibe-runtime/runtime-token-economy-model.mjs

@@ -0,0 +1,336 @@
+export const tokenCompactorDefinitions = Object.freeze([
+  { id: 'git-status', command_names: ['git status', 'git status --short', 'git status --short --branch'], family: 'git', dropped_categories: ['branch prose', 'clean tree prose', 'untracked instructions'] },
+  { id: 'git-diff-stat', command_names: ['git diff --stat'], family: 'git', dropped_categories: ['blank lines', 'localized line ending warnings'] },
+  { id: 'git-log-oneline', command_names: ['git log --oneline'], family: 'git', dropped_categories: ['duplicate blank lines'] },
+  { id: 'node-check', command_names: ['node --check'], family: 'syntax', dropped_categories: ['empty success output'] },
+  { id: 'vibe-runtime-check', command_names: ['vibe-runtime-check', 'node tools/vibe-runtime-check/index.mjs'], family: 'runtime-check', dropped_categories: ['repeated ok lines', 'line ending warnings'] },
+  { id: 'vibe-release-check', command_names: ['vibe-release-check', 'node tools/vibe-release-check/index.mjs'], family: 'release-check', dropped_categories: ['repeated ok lines', 'accepted non-zero smoke details', 'line ending warnings'] },
+  { id: 'test-lint-pass', command_names: ['test', 'lint', 'npm test', 'npm run lint', 'pytest', 'vitest'], family: 'test-lint', dropped_categories: ['pass-only noise', 'duplicate blank lines'] },
+]);
+
+export function tokenCompactorIds() {
+  return tokenCompactorDefinitions.map((definition) => definition.id).sort();
+}
+
+const tokenProfileDefinitions = Object.freeze({
+  minimal: {
+    name: 'minimal',
+    target: 'short interactive status and pass/fail summaries',
+    output_budget: 'lowest',
+    preserve: ['failure lines', 'digests', 'counts', 'artifact filenames'],
+    prefer_compactors: ['git-status', 'node-check', 'vibe-runtime-check', 'vibe-release-check', 'test-lint-pass'],
+    recommended_rewrites: ['git status --short --branch', 'pytest -q --tb=line', 'tsc --pretty false'],
+  },
+  balanced: {
+    name: 'balanced',
+    target: 'default deterministic compaction with enough context for review',
+    output_budget: 'moderate',
+    preserve: ['failure lines', 'warnings', 'summary counts', 'digests', 'top changed files'],
+    prefer_compactors: tokenCompactorIds(),
+    recommended_rewrites: ['git status --short --branch', 'pytest -q --tb=line', 'tsc --pretty false'],
+  },
+  full: {
+    name: 'full',
+    target: 'digest-bound evidence with minimal dropping and no hidden originals',
+    output_budget: 'highest',
+    preserve: ['failure lines', 'warnings', 'summary counts', 'digests', 'changed files', 'selected raw excerpts'],
+    prefer_compactors: tokenCompactorIds(),
+    recommended_rewrites: [],
+  },
+});
+
+export function tokenProfileNames() {
+  return Object.keys(tokenProfileDefinitions).sort();
+}
+
+export function normalizeTokenCommandName(commandName) {
+  return String(commandName || '').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+
+export function tokenCompactorDefinition(commandName) {
+  const normalized = normalizeTokenCommandName(commandName);
+  const exact = tokenCompactorDefinitions.find((definition) => definition.command_names.map(normalizeTokenCommandName).includes(normalized));
+  if (exact) return exact;
+  if (normalized.startsWith('git status')) return tokenCompactorDefinitions.find((definition) => definition.id === 'git-status');
+  if (normalized.startsWith('git diff') && normalized.includes('--stat')) return tokenCompactorDefinitions.find((definition) => definition.id === 'git-diff-stat');
+  if (normalized.startsWith('git log') && normalized.includes('--oneline')) return tokenCompactorDefinitions.find((definition) => definition.id === 'git-log-oneline');
+  if (normalized.startsWith('node --check')) return tokenCompactorDefinitions.find((definition) => definition.id === 'node-check');
+  if (normalized.includes('vibe-runtime-check')) return tokenCompactorDefinitions.find((definition) => definition.id === 'vibe-runtime-check');
+  if (normalized.includes('vibe-release-check')) return tokenCompactorDefinitions.find((definition) => definition.id === 'vibe-release-check');
+  if (/(test|lint|pytest|vitest)/.test(normalized)) return tokenCompactorDefinitions.find((definition) => definition.id === 'test-lint-pass');
+  throw new Error(`unsupported token compactor command: ${commandName}`);
+}
+
+export function tokenEconomyBoundaryAssertions() {
+  return {
+    shell_interception: false,
+    command_execution: false,
+    output_mutation: false,
+    original_output_hidden: false,
+    external_network: false,
+    model_invocation: false,
+    platform_api: false,
+    git: false,
+    worktree: false,
+    business_source_write: false,
+    runtime_action: false,
+    auto_execution: false,
+    subagent: false,
+    mcp: false,
+    daemon: false,
+  };
+}
+
+export function compactLinesForDefinition(definition, text) {
+  const lines = String(text || '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+  const nonEmpty = lines.map((line) => line.trimEnd()).filter((line) => line.trim() !== '');
+  const warnings = nonEmpty.filter((line) => /^warning:/i.test(line));
+  const failures = nonEmpty.filter((line) => /\b(fail|failed|error|fatal|exception|traceback|not ok)\b/i.test(line));
+  if (definition.id === 'git-status') {
+    const statusLines = nonEmpty.filter((line) => /^(##|[ MADRCU?!]{1,2}\s+)/.test(line));
+    const branch = statusLines.find((line) => line.startsWith('##')) || '';
+    const changes = statusLines.filter((line) => !line.startsWith('##'));
+    return [`command_family=git-status`, branch ? `branch=${branch.slice(3)}` : 'branch=not-recorded', `changes=${changes.length}`, ...changes.slice(0, 40)];
+  }
+  if (definition.id === 'git-diff-stat') {
+    const summary = nonEmpty.find((line) => /files? changed|insertions?|deletions?/i.test(line)) || 'summary=not-recorded';
+    const files = nonEmpty.filter((line) => line.includes('|')).slice(0, 40);
+    return ['command_family=git-diff-stat', summary, ...files];
+  }
+  if (definition.id === 'git-log-oneline') return ['command_family=git-log-oneline', `commits=${nonEmpty.length}`, ...nonEmpty.slice(0, 30)];
+  if (definition.id === 'node-check') return ['command_family=node-check', failures.length === 0 ? 'syntax=passed' : 'syntax=failed', ...failures.slice(0, 30), ...warnings.slice(0, 10)];
+  if (definition.id === 'vibe-runtime-check' || definition.id === 'vibe-release-check') {
+    const okCount = nonEmpty.filter((line) => line.startsWith('[ok]')).length;
+    const warnCount = nonEmpty.filter((line) => line.startsWith('[warn]')).length;
+    const failCount = nonEmpty.filter((line) => line.startsWith('[fail]')).length;
+    const result = [...nonEmpty].reverse().find((line) => line.startsWith('Result:')) || 'Result: unknown';
+    const checks = [...nonEmpty].reverse().find((line) => line.startsWith('Checks:')) || '';
+    return [`command_family=${definition.id}`, result, checks, `ok_lines=${okCount}`, `warn_lines=${warnCount}`, `fail_lines=${failCount}`, ...failures.slice(0, 40), ...warnings.slice(0, 20)];
+  }
+  const passed = failures.length === 0;
+  const resultLine = [...nonEmpty].reverse().find((line) => /\b(pass|passed|success|ok|fail|failed|error)\b/i.test(line)) || (passed ? 'result=passed-or-no-failures-detected' : 'result=failed');
+  return ['command_family=test-lint', resultLine, `failures=${failures.length}`, ...failures.slice(0, 40), ...warnings.slice(0, 20)];
+}
+
+export function estimateTokenCount(text) {
+  return Math.ceil(String(text || '').length / 4);
+}
+
+export function buildTokenCompactorCatalogModel({ digestObject }) {
+  const catalog = {
+    version: 1,
+    stage: 'Stage 63',
+    catalog_kind: 'token-compactor-catalog',
+    source: 'builtin-data-only',
+    deterministic: true,
+    pure_function: true,
+    dynamic_code: false,
+    remote_config: false,
+    external_network: false,
+    model_invocation: false,
+    shell_interception: false,
+    command_execution: false,
+    compactors: tokenCompactorDefinitions.map((definition) => ({ ...definition, version: 1 })).sort((left, right) => left.id.localeCompare(right.id)),
+  };
+  return { ...catalog, catalog_digest: digestObject(catalog) };
+}
+
+export function buildTokenProfileModel(profileName, { digestObject }) {
+  const name = String(profileName || '').trim() || 'balanced';
+  const definition = tokenProfileDefinitions[name];
+  if (!definition) throw new Error(`unsupported token profile: ${name}`);
+  const profile = {
+    version: 1,
+    stage: 'Stage 64',
+    profile_kind: 'token-profile',
+    ...definition,
+    deterministic: true,
+    builtin_data_only: true,
+    shell_interception: false,
+    command_execution: false,
+    output_mutation: false,
+    external_network: false,
+    model_invocation: false,
+  };
+  return { ...profile, profile_digest: digestObject(profile) };
+}
+
+function tokenAdviceBoundaryAssertions() {
+  return { ...tokenEconomyBoundaryAssertions(), command_mutation: false };
+}
+
+function normalizeTokenAdviceIntent(intent) {
+  const value = String(intent || '').trim().toLowerCase();
+  const known = new Set(['status', 'verification', 'review', 'context', 'feature', 'debug', 'implementation', 'completion', 'command']);
+  return known.has(value) ? value : 'unknown';
+}
+
+function tokenAdviceProfileName(intent, commandName = '') {
+  const normalizedCommand = normalizeTokenCommandName(commandName);
+  if (normalizedCommand.startsWith('git status') || normalizedCommand.startsWith('node --check')) return 'minimal';
+  if (/^(pytest|python -m pytest)\b/.test(normalizedCommand) || /\b(tsc|vitest|lint|test)\b/.test(normalizedCommand)) return 'minimal';
+  if (intent === 'status' || intent === 'verification' || intent === 'completion') return 'minimal';
+  if (intent === 'review' || intent === 'context') return 'full';
+  return 'balanced';
+}
+
+function compactTokenCompactor(definition) {
+  return {
+    id: definition.id,
+    family: definition.family,
+    command_names: [...definition.command_names],
+    dropped_categories: [...definition.dropped_categories],
+  };
+}
+
+function tokenAdviceCompactors(intent, commandName = '') {
+  const command = String(commandName || '').trim();
+  if (command) {
+    try {
+      return [compactTokenCompactor(tokenCompactorDefinition(command))];
+    } catch {
+      return [];
+    }
+  }
+  const idsByIntent = {
+    status: ['git-status', 'git-diff-stat', 'git-log-oneline'],
+    verification: ['node-check', 'vibe-runtime-check', 'vibe-release-check', 'test-lint-pass'],
+    review: tokenCompactorIds(),
+    context: tokenCompactorIds(),
+    feature: ['git-status', 'git-diff-stat', 'node-check', 'vibe-runtime-check', 'vibe-release-check', 'test-lint-pass'],
+    debug: ['node-check', 'test-lint-pass', 'vibe-runtime-check'],
+    implementation: ['git-status', 'git-diff-stat', 'node-check', 'test-lint-pass'],
+    completion: ['git-status', 'git-diff-stat', 'git-log-oneline', 'vibe-runtime-check', 'vibe-release-check'],
+    command: tokenCompactorIds(),
+    unknown: ['git-status', 'git-diff-stat', 'node-check', 'vibe-runtime-check', 'vibe-release-check'],
+  };
+  const ids = idsByIntent[intent] || idsByIntent.unknown;
+  return ids
+    .map((id) => tokenCompactorDefinitions.find((definition) => definition.id === id))
+    .filter(Boolean)
+    .map(compactTokenCompactor);
+}
+
+function tokenAdviceRewritePreviews(profile, commandName, digestObject) {
+  const command = String(commandName || '').trim();
+  if (command) return [buildTokenRewritePreviewModel(command, { digestObject })];
+  return (profile.recommended_rewrites || []).map((rewriteCommand) => buildTokenRewritePreviewModel(rewriteCommand, { digestObject }));
+}
+
+function tokenAdviceManualAction(intent, commandName = '') {
+  const command = String(commandName || '').trim();
+  if (command) return 'Run the suggested compact command form manually if it fits the task, then use tokens --compact-output only on saved local output evidence.';
+  if (intent === 'status') return 'Prefer short status and stat commands before asking for broader context.';
+  if (intent === 'verification') return 'Prefer quiet deterministic verification output and preserve failure lines, counts, and digests.';
+  if (intent === 'review' || intent === 'context') return 'Use the full profile only when review evidence or selected raw excerpts are needed.';
+  return 'Choose the recommended profile first, then use the listed compactors only for local saved command output.';
+}
+
+function tokenAdviceVerificationHint(intent) {
+  if (intent === 'verification') return 'After compaction, verify token sidecars with tokens --verify and keep original output digest-bound.';
+  if (intent === 'status') return 'Confirm advice remains read-only by checking that no .vibecoding-state directory is created.';
+  return 'Use tokens --catalog, tokens --profile, and tokens --rewrite-preview to independently reproduce this advice.';
+}
+
+export function buildTokenAdviceModel({ intent = '', commandName = '', statePresent = false, digestObject } = {}) {
+  const inputIntent = String(intent || '').trim();
+  const command = String(commandName || '').trim();
+  const normalizedIntent = normalizeTokenAdviceIntent(inputIntent || (command ? 'command' : 'context'));
+  const profile = buildTokenProfileModel(tokenAdviceProfileName(normalizedIntent, command), { digestObject });
+  const catalog = buildTokenCompactorCatalogModel({ digestObject });
+  const rewritePreviews = tokenAdviceRewritePreviews(profile, command, digestObject);
+  const boundaryAssertions = tokenAdviceBoundaryAssertions();
+  const quality = [];
+  if (inputIntent && normalizedIntent === 'unknown') quality.push('unknown token advice intent; using balanced profile and general deterministic compactors');
+  if (command && tokenAdviceCompactors(normalizedIntent, command).length === 0) quality.push('command has no matching builtin compactor; rewrite advice remains preview-only');
+  const advice = {
+    version: 1,
+    stage: 'Stage 79',
+    advice_kind: 'token-saving-advice',
+    intent: normalizedIntent,
+    input_intent: inputIntent,
+    command,
+    recommended_profile: profile.name,
+    profile_budget: profile.output_budget,
+    recommended_compactors: tokenAdviceCompactors(normalizedIntent, command),
+    recommended_rewrites: rewritePreviews.map((preview) => ({
+      command: preview.command,
+      suggested_command: preview.suggested_command,
+      changed: preview.changed,
+      rule: preview.rule,
+      reason: preview.reason,
+      execute: preview.execute,
+      shell_interception: preview.shell_interception,
+      command_mutation: preview.command_mutation,
+      rewrite_preview_digest: preview.rewrite_preview_digest,
+    })),
+    manual_action: tokenAdviceManualAction(normalizedIntent, command),
+    verification_hint: tokenAdviceVerificationHint(normalizedIntent),
+    catalog_digest: catalog.catalog_digest,
+    profile_digest: profile.profile_digest,
+    boundary_assertions: boundaryAssertions,
+    writes: false,
+    state_directory_created: false,
+    no_execution: true,
+    local_only: true,
+  };
+  return {
+    mode: 'token-saving-advice',
+    ok: true,
+    state_present: Boolean(statePresent),
+    token_advice: { ...advice, advice_digest: digestObject(advice) },
+    safety: {
+      stage: 'Stage 79',
+      writes: false,
+      token_advice_artifact: false,
+      ...boundaryAssertions,
+    },
+    quality,
+    action: 'token saving advice was computed read-only from builtin deterministic token catalog, profile, and rewrite rules. No state directory, shell interception, command execution, command mutation, output mutation, hidden original output, external network, model, platform API, git, worktree, subagent, MCP, daemon, or business source mutation occurred.',
+  };
+}
+
+export function buildTokenAuditSummaryModel(kind, file, artifact) {
+  if (kind === 'token-metrics') return { file, compaction_count: artifact.token_metrics?.totals?.compaction_count || 0, estimated_tokens_saved: artifact.token_metrics?.totals?.estimated_tokens_saved || 0, savings_ratio: artifact.token_metrics?.totals?.savings_ratio ?? 0, token_metrics_digest: artifact.token_metrics?.token_metrics_digest || '' };
+  if (kind === 'token-compaction') return { file, command_name: artifact.token_compaction?.command_name || '', compactor_id: artifact.token_compaction?.compactor_id || '', savings_ratio: artifact.token_compaction?.metrics?.savings_ratio ?? 0, token_compaction_digest: artifact.token_compaction?.token_compaction_digest || '' };
+  throw new Error(`unsupported token audit summary kind: ${kind}`);
+}
+
+export function buildTokenRewritePreviewModel(commandName, { digestObject }) {
+  const command = String(commandName || '').trim();
+  if (!command) throw new Error('tokens --rewrite-preview requires --command <cmd>');
+  const normalized = normalizeTokenCommandName(command);
+  let suggested = command;
+  let rule = 'no-deterministic-rewrite';
+  let reason = 'command already appears compact or has no builtin rewrite rule';
+  if (normalized.startsWith('git status') && !/\s(--short|-s|-sb)\b/.test(normalized)) {
+    suggested = 'git status --short --branch';
+    rule = 'git-status-short-branch';
+    reason = 'short branch status removes prose while preserving branch and change entries';
+  } else if (/^(pytest|python -m pytest)\b/.test(normalized) && !/\s-q\b/.test(normalized)) {
+    suggested = `${command} -q --tb=line`;
+    rule = 'pytest-quiet-line-traceback';
+    reason = 'quiet mode and line traceback reduce pass noise while preserving failing locations';
+  } else if (/\btsc\b/.test(normalized) && !normalized.includes('--pretty false')) {
+    suggested = `${command} --pretty false`;
+    rule = 'tsc-no-pretty';
+    reason = 'non-pretty diagnostics are deterministic and easier to compact';
+  }
+  const preview = {
+    version: 1,
+    stage: 'Stage 64',
+    preview_kind: 'token-rewrite-preview',
+    command,
+    normalized_command: normalized,
+    suggested_command: suggested,
+    changed: suggested !== command,
+    rule,
+    reason,
+    execute: false,
+    shell_interception: false,
+    command_mutation: false,
+    deterministic: true,
+    boundary_assertions: tokenEconomyBoundaryAssertions(),
+  };
+  return { ...preview, rewrite_preview_digest: digestObject(preview) };
+}