@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime-check/runtime-source-bundle.mjs

@@ -0,0 +1,119 @@
+function normalizeMarkers(markers) {
+  return [...new Set((markers || []).filter(Boolean))];
+}
+
+function createMarkerIndex(bundle, markers) {
+  const markerList = normalizeMarkers(markers);
+  const byMarker = Object.fromEntries(markerList.map((marker) => [marker, []]));
+  const byFile = Object.fromEntries(bundle.map((entry) => [entry.file, []]));
+
+  for (const entry of bundle) {
+    for (const marker of markerList) {
+      if (!entry.text.includes(marker)) continue;
+      byMarker[marker].push(entry.file);
+      byFile[entry.file].push(marker);
+    }
+  }
+
+  function filesFor(marker) {
+    return byMarker[marker] || [];
+  }
+
+  function has(marker) {
+    return filesFor(marker).length > 0;
+  }
+
+  function missing(targetMarkers = markerList) {
+    return normalizeMarkers(targetMarkers).filter((marker) => !has(marker));
+  }
+
+  return {
+    markers: markerList,
+    files: bundle.map((entry) => entry.file),
+    byMarker,
+    byFile,
+    filesFor,
+    has,
+    missing,
+    toLegacyRows() {
+      return markerList.map((marker) => ({ marker, files: filesFor(marker) }));
+    },
+  };
+}
+
+function callExists(api, root, file) {
+  return root === undefined ? api.exists(file) : api.exists(root, file);
+}
+
+function callReadText(api, root, file) {
+  return root === undefined ? api.readText(file) : api.readText(root, file);
+}
+
+export function createSourceTextReader(api, root = undefined) {
+  const existsCache = new Map();
+  const textCache = new Map();
+  const counters = {
+    exists: { hits: 0, misses: 0 },
+    readText: { hits: 0, misses: 0, skippedMissing: 0 },
+  };
+
+  function exists(file) {
+    if (existsCache.has(file)) {
+      counters.exists.hits += 1;
+      return existsCache.get(file);
+    }
+    counters.exists.misses += 1;
+    existsCache.set(file, callExists(api, root, file));
+    return existsCache.get(file);
+  }
+
+  function readText(file) {
+    if (!exists(file)) {
+      counters.readText.skippedMissing += 1;
+      return '';
+    }
+    if (textCache.has(file)) {
+      counters.readText.hits += 1;
+      return textCache.get(file);
+    }
+    counters.readText.misses += 1;
+    textCache.set(file, callReadText(api, root, file));
+    return textCache.get(file);
+  }
+
+  function readSourceBundle(files) {
+    return files.map((file) => ({ file, exists: exists(file), text: readText(file) }));
+  }
+
+  function joinSourceTexts(files) {
+    return readSourceBundle(files).map((entry) => entry.text).join('\n');
+  }
+
+  function buildMarkerIndex(files, markers) {
+    return createMarkerIndex(readSourceBundle(files), markers).toLegacyRows();
+  }
+
+  function markerIndex(files, markers) {
+    return createMarkerIndex(readSourceBundle(files), markers);
+  }
+
+  function groupedMarkerIndex(groups, markersByGroup = {}) {
+    return Object.fromEntries(Object.entries(groups).map(([group, files]) => [
+      group,
+      markerIndex(files, markersByGroup[group] || []),
+    ]));
+  }
+
+  function stats() {
+    return {
+      exists: { ...counters.exists, cached: existsCache.size },
+      readText: { ...counters.readText, cached: textCache.size },
+    };
+  }
+
+  return { exists, readText, readSourceBundle, joinSourceTexts, buildMarkerIndex, markerIndex, groupedMarkerIndex, stats };
+}
+
+export function getSourceTextReader(api, root = undefined) {
+  return api?.sourceReader || createSourceTextReader(api, root);
+}

package/tools/vibe-runtime-check/runtime-tool-readme-contracts.mjs

@@ -0,0 +1,93 @@
+import { checkRuntimeAutomationReadinessContracts } from './runtime-automation-readiness-contracts.mjs';
+import { checkRuntimeCapabilityRegistryContracts } from './runtime-capability-registry-contracts.mjs';
+import { checkRuntimeCliSurfaceContracts } from './runtime-cli-surface-contracts.mjs';
+import { checkRuntimeCloseLoopContracts } from './runtime-close-loop-contracts.mjs';
+import { checkRuntimeExperienceCliContracts } from './runtime-experience-cli-contracts.mjs';
+import { checkRuntimeExperienceContracts } from './runtime-experience-contracts.mjs';
+import { checkRuntimeGovernanceLearningTokenContracts } from './runtime-governance-learning-token-contracts.mjs';
+import { checkRuntimeReleaseCloseoutContracts } from './runtime-release-closeout-contracts.mjs';
+import { checkWorkflowUxContracts } from './workflow-ux-contracts.mjs';
+import { runtimeCliSurfaceFiles } from '../vibe-runtime/runtime-command-surface-registry.mjs';
+import { getSourceTextReader } from './runtime-source-bundle.mjs';
+import { checkRuntimeMarkerSpecs, runtimeToolCliSurfaceMarkerSpecs, runtimeToolReadmeMarkerSpecs } from './runtime-tool-readme-marker-specs.mjs';
+
+const qName = ['que', 'ue'].join('');
+const schedName = ['sche', 'duler'].join('');
+
+export function checkRuntimeToolReadmeContracts(root, api) {
+  const { exists, readText, ok, fail } = api;
+  const toolFiles = [
+    'tools/vibe-runtime/index.mjs',
+    'tools/vibe-runtime/README.md',
+  ];
+  const runtimeMarkerContractOwnerFiles = [
+    'tools/vibe-runtime/runtime-governance-attestation.mjs',
+    'tools/vibe-runtime/runtime-control-plane-evals-cases.mjs',
+    'tools/vibe-runtime/runtime-review-envelope.mjs',
+    'tools/vibe-runtime/runtime-executable-plan-contract.mjs',
+    'tools/vibe-runtime/runtime-plan-action-manifest.mjs',
+    'tools/vibe-runtime/runtime-evidence-intake-envelope.mjs',
+    'tools/vibe-runtime/runtime-control-plane-planning-validation.mjs',
+    'tools/vibe-runtime/runtime-control-plane-readonly-command.mjs',
+    'tools/vibe-runtime/runtime-subagents-eligibility-model.mjs',
+    'tools/vibe-runtime/runtime-subagents-risk-artifacts.mjs',
+    'tools/vibe-runtime/runtime-subagents-stage-artifact-model.mjs',
+    'tools/vibe-runtime/runtime-platform-capability-artifacts.mjs',
+    'tools/vibe-runtime/runtime-platform-session-artifacts.mjs',
+    'tools/vibe-runtime/runtime-dispatch-readonly-artifacts.mjs',
+    'tools/vibe-runtime/runtime-execution-policy-artifacts.mjs',
+    'tools/vibe-runtime/runtime-execution-readonly-artifacts.mjs',
+    'tools/vibe-runtime/runtime-execution-safety-artifacts.mjs',
+    'tools/vibe-runtime/runtime-execution-plan-artifacts.mjs',
+    'tools/vibe-runtime/runtime-execution-run-preflight-artifacts.mjs',
+    'tools/vibe-runtime/runtime-execution-candidate-approval-artifacts.mjs',
+    'tools/vibe-runtime/runtime-execution-presentation.mjs',
+    'tools/vibe-runtime/runtime-eval-catalog-model.mjs',
+    'tools/vibe-runtime/runtime-staged-commit-readiness.mjs',
+    'tools/vibe-runtime/runtime-workflow-alias-boundary-text.mjs',
+    'tools/vibe-runtime/runtime-recovery-state-lifecycle-model.mjs',
+    `tools/vibe-runtime/runtime-${schedName}-risk-artifacts.mjs`,
+    'tools/vibe-runtime/runtime-daemon-state-lifecycle-model.mjs',
+    `tools/vibe-runtime/runtime-${qName}-state-lifecycle-model.mjs`,
+    'tools/vibe-runtime/runtime-observability-readiness-model.mjs',
+  ];
+
+  for (const file of toolFiles) {
+    if (exists(root, file)) ok(`${file} exists`);
+    else fail(`${file} missing`, '', `Restore ${file}; Stage 2 ledger checks expect the explicit runtime state tool.`);
+  }
+
+  if (exists(root, 'tools/vibe-runtime/README.md')) {
+    const text = readText(root, 'tools/vibe-runtime/README.md');
+    checkRuntimeMarkerSpecs(runtimeToolReadmeMarkerSpecs, text, { ok, fail });
+
+  }
+
+  if (exists(root, 'tools/vibe-runtime/index.mjs')) {
+    const sourceReader = getSourceTextReader(api, root);
+    const cliDispatchText = sourceReader.readText('tools/vibe-runtime/runtime-cli-dispatch.mjs');
+    const cliSurfaceText = sourceReader.joinSourceTexts([
+      ...runtimeCliSurfaceFiles,
+      ...runtimeMarkerContractOwnerFiles,
+      'tools/vibe-runtime/runtime-control-plane-planning-presentation.mjs',
+    ]);
+    checkRuntimeMarkerSpecs(runtimeToolCliSurfaceMarkerSpecs, cliSurfaceText, { ok, fail });
+    checkRuntimeCliSurfaceContracts(root, { exists, readText, ok, fail }, { cliDispatchText, cliSurfaceText });
+
+    checkRuntimeGovernanceLearningTokenContracts({ ok, fail }, cliSurfaceText);
+
+    checkWorkflowUxContracts(root, { ok, fail }, cliSurfaceText);
+
+    checkRuntimeReleaseCloseoutContracts({ ok, fail }, cliSurfaceText);
+
+    checkRuntimeExperienceCliContracts({ ok, fail }, cliSurfaceText);
+  }
+
+  checkRuntimeCapabilityRegistryContracts(root, { exists, readText, ok, fail });
+
+  checkRuntimeAutomationReadinessContracts(root, { exists, readText, ok, fail });
+
+  checkRuntimeCloseLoopContracts(root, { exists, readText, ok, fail });
+
+  checkRuntimeExperienceContracts(root, { exists, readText, ok, fail });
+}