@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-platform-transcript-example-pack.mjs

@@ -0,0 +1,293 @@
+import crypto from 'node:crypto';
+
+export const platformTranscriptExamplePackStage = 'P22';
+export const platformTranscriptExamplePackKind = 'platform-transcript-example-pack';
+
+const baselineAdapters = ['claude', 'cursor', 'codex', 'opencode', 'pi'];
+const exampleTopics = [
+  'session_start',
+  'workflow_entry',
+  'sdd_brief_chain',
+  'review_blocker',
+  'resume_dedupe',
+  'completion_evidence',
+];
+const zeroDigest = '0'.repeat(64);
+
+export function runtimePlatformTranscriptExamplePack({ adapters = baselineAdapters } = {}) {
+  const adapterList = unique(compactStrings(adapters)).filter((adapter) => baselineAdapters.includes(adapter));
+  const examples = exampleTopics.flatMap((topic) => adapterList.map((adapter) => transcriptExample(adapter, topic)));
+  const packCore = {
+    version: 1,
+    stage: platformTranscriptExamplePackStage,
+    pack_kind: platformTranscriptExamplePackKind,
+    adapter_scope: adapterList,
+    topic_scope: exampleTopics,
+    input_summary: {
+      adapter_count: adapterList.length,
+      topic_count: exampleTopics.length,
+      example_count: examples.length,
+    },
+    transcript_examples: examples,
+    copy_ready_notes: copyReadyNotes(),
+    boundary_assertions: transcriptExamplePackBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+  };
+  const invariants = transcriptExamplePackInvariants(packCore);
+  const pack = {
+    ...packCore,
+    ok: invariants.pass,
+    example_pack_invariants: invariants,
+  };
+  return {
+    ...pack,
+    example_pack_digest: digestObject(transcriptExamplePackDigestPayload(pack)),
+  };
+}
+
+export function transcriptExamplePackDigestPayload(pack) {
+  return {
+    stage: pack.stage,
+    pack_kind: pack.pack_kind,
+    adapter_scope: pack.adapter_scope,
+    topic_scope: pack.topic_scope,
+    input_summary: pack.input_summary,
+    transcript_examples: pack.transcript_examples,
+    copy_ready_notes: pack.copy_ready_notes,
+    boundary_assertions: pack.boundary_assertions,
+    example_pack_invariants: pack.example_pack_invariants,
+  };
+}
+
+export function transcriptExamplePackBoundaryAssertions() {
+  return {
+    transcript_example_pack_artifact: false,
+    transcript_export_artifact: false,
+    sidecar_write: false,
+    state_directory_created: false,
+    command_execution: false,
+    test_execution: false,
+    check_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    hook_execution: false,
+    adapter_execution: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    git: false,
+    git_write: false,
+    commit: false,
+    pr: false,
+    push: false,
+    merge: false,
+    worktree: false,
+    business_source_write: false,
+  };
+}
+
+export function transcriptExamplePackInvariants(pack) {
+  const unsafeBoundaries = Object.entries(pack.boundary_assertions || {})
+    .filter(([, value]) => value !== false)
+    .map(([key]) => key);
+  const missingBoundaries = Object.keys(transcriptExamplePackBoundaryAssertions())
+    .filter((key) => pack.boundary_assertions?.[key] !== false);
+  const exampleKeys = (pack.transcript_examples || []).map((example) => `${example.adapter}:${example.topic}`);
+  const duplicateExamples = exampleKeys.filter((key, index, items) => items.indexOf(key) !== index);
+  const parsedFindings = (pack.transcript_examples || []).flatMap(exampleJsonFindings);
+  const findings = [
+    ...(pack.stage === platformTranscriptExamplePackStage ? [] : [`stage must be ${platformTranscriptExamplePackStage}`]),
+    ...(pack.pack_kind === platformTranscriptExamplePackKind ? [] : [`pack_kind must be ${platformTranscriptExamplePackKind}`]),
+    ...(Array.isArray(pack.adapter_scope) && pack.adapter_scope.length >= 5 ? [] : ['adapter_scope must include claude, cursor, codex, opencode, and pi']),
+    ...(Array.isArray(pack.topic_scope) && pack.topic_scope.length === exampleTopics.length ? [] : ['topic_scope must include every transcript export topic']),
+    ...(Array.isArray(pack.transcript_examples) && pack.transcript_examples.length >= 30 ? [] : ['transcript_examples must cover every adapter/topic pair']),
+    ...baselineAdapters.filter((adapter) => !pack.adapter_scope?.includes(adapter)).map((adapter) => `missing adapter example scope: ${adapter}`),
+    ...exampleTopics.filter((topic) => !pack.topic_scope?.includes(topic)).map((topic) => `missing transcript topic: ${topic}`),
+    ...duplicateExamples.map((key) => `duplicate transcript example: ${key}`),
+    ...parsedFindings,
+    ...unsafeBoundaries.map((key) => `boundary assertion must remain false: ${key}`),
+    ...missingBoundaries.map((key) => `forbidden boundary missing or not false: ${key}`),
+  ];
+  return {
+    pass: findings.length === 0,
+    checked: ['adapter_scope', 'topic_scope', 'copy_ready_json', 'read_only_boundary_assertions'],
+    findings,
+  };
+}
+
+function transcriptExample(adapter, topic) {
+  const payload = transcriptPayload(adapter, topic);
+  const exportPayload = { ...payload, export_digest: digestObject(payload) };
+  return {
+    adapter,
+    topic,
+    file_name: `.vibecoding/transcripts/${adapter}-${topic}.json`,
+    intake_hint: 'Save the JSON under the project root and pass that local file to the documented transcript intake path.',
+    copy_ready_json: JSON.stringify(exportPayload, null, 2),
+    boundary_summary: 'Manual local transcript export only; the adapter records text and local artifact refs without executing skills, commands, hooks, platform APIs, model calls, subagents, MCP, or git.',
+  };
+}
+
+function transcriptPayload(adapter, topic) {
+  return {
+    platform: adapter,
+    source: sourceShape(adapter, topic),
+    turns: turnsForTopic(topic),
+    observed: observedForTopic(topic),
+    artifact_refs: artifactRefsForTopic(topic),
+    boundary_assertions: exportBoundaryAssertions(),
+  };
+}
+
+function sourceShape(adapter, topic) {
+  return {
+    adapter,
+    export_kind: 'manual_local_transcript_json',
+    example_topic: topic,
+    origin: 'copy_ready_adapter_example',
+  };
+}
+
+function turnsForTopic(topic) {
+  const byTopic = {
+    session_start: [
+      ['system', 'Vibecoding bootstrap marker visible. Load using-vibecoding lightly; do not inject the full skill.'],
+      ['assistant', 'I will start with lightweight routing and keep runtime actions local/read-only unless you explicitly authorize a stronger step.'],
+    ],
+    workflow_entry: [
+      ['user', 'Implement this planned task.'],
+      ['assistant', 'Route: using-vibecoding L1. Validation: syntax check and targeted runtime check. Stop condition: no source write beyond the task scope.'],
+    ],
+    sdd_brief_chain: [
+      ['assistant', 'Task brief prepared with owner, files, checks, done criteria, and stop conditions.'],
+      ['assistant', 'Implementer artifact references a local report and review package; status is DONE only with evidence.'],
+    ],
+    review_blocker: [
+      ['reviewer', 'BLOCKER: completion evidence is missing for the changed runtime file.'],
+      ['assistant', 'Blocked until the missing evidence is supplied; do not continue to the next task.'],
+    ],
+    resume_dedupe: [
+      ['system', 'Vibecoding bootstrap marker already present in this session.'],
+      ['assistant', 'Resume detected; keep a single lightweight entry summary and avoid duplicate full skill text.'],
+    ],
+    completion_evidence: [
+      ['assistant', 'Changed files are listed, checks are named, and evidence is attached before claiming completion.'],
+      ['assistant', 'No git commit, push, PR, platform API, model judge, or subagent session was used.'],
+    ],
+  };
+  return byTopic[topic].map(([role, content]) => ({ role, content }));
+}
+
+function observedForTopic(topic) {
+  const markerMap = {
+    session_start: ['using-vibecoding', 'bootstrap_marker', 'full_skill_injection=false'],
+    workflow_entry: ['route=L1', 'validation_strategy_present', 'stop_condition_present'],
+    sdd_brief_chain: ['task_brief_present', 'review_package_present', 'implementer_artifact_present'],
+    review_blocker: ['review_blocker_present', 'next_task_blocked'],
+    resume_dedupe: ['dedupe_marker_present', 'single_entry_summary'],
+    completion_evidence: ['completion_evidence_present', 'checks_named', 'no_git_write'],
+  };
+  return {
+    commands: [],
+    markers: markerMap[topic] || [],
+    blocked_reasons: topic === 'review_blocker' ? ['review blocker stops next task'] : [],
+    workflow_order: workflowOrderForTopic(topic),
+    claims: claimsForTopic(topic),
+  };
+}
+
+function workflowOrderForTopic(topic) {
+  if (topic === 'sdd_brief_chain') return ['task_brief', 'review_package', 'implementer_artifact'];
+  if (topic === 'workflow_entry') return ['using-vibecoding', 'selected_workflow', 'validation_strategy'];
+  return [];
+}
+
+function claimsForTopic(topic) {
+  if (topic === 'completion_evidence') return [{ claim: 'complete', evidence: ['syntax_check', 'runtime_check'] }];
+  if (topic === 'review_blocker') return [{ claim: 'blocked', evidence: ['reviewer_blocker'] }];
+  return [];
+}
+
+function artifactRefsForTopic(topic) {
+  const refs = {
+    sdd_brief_chain: [
+      { path: '.vibecoding/transcript-artifacts/sdd/example-task.md', digest: zeroDigest, kind: 'task_brief' },
+      { path: '.vibecoding/transcript-artifacts/sdd/example-review.md', digest: zeroDigest, kind: 'review_package' },
+      { path: '.vibecoding/transcript-artifacts/sdd/example-result.json', digest: zeroDigest, kind: 'implementer_artifact' },
+    ],
+    review_blocker: [{ path: '.vibecoding/transcript-artifacts/sdd/blocker-review.md', digest: zeroDigest, kind: 'review_blocker' }],
+    completion_evidence: [{ path: '.vibecoding/transcript-artifacts/evidence/example-check.json', digest: zeroDigest, kind: 'completion_evidence' }],
+  };
+  return refs[topic] || [];
+}
+
+function exportBoundaryAssertions() {
+  return {
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    mcp: false,
+    git: false,
+    git_write: false,
+    command_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    runtime_action: false,
+    source_write: false,
+    business_source_write: false,
+  };
+}
+
+function copyReadyNotes() {
+  return [
+    'Save one JSON object to a project-local file, then pass that file to the documented transcript intake path.',
+    'The transcript may mention commands as text evidence, but the intake path never executes them.',
+    'Artifact refs are local evidence pointers only; the example pack does not create those files.',
+  ];
+}
+
+function exampleJsonFindings(example) {
+  try {
+    const parsed = JSON.parse(example.copy_ready_json);
+    return [
+      ...(baselineAdapters.includes(parsed.platform) ? [] : [`${example.adapter}:${example.topic} platform must be supported`]),
+      ...(Array.isArray(parsed.turns) && parsed.turns.length > 0 ? [] : [`${example.adapter}:${example.topic} turns are required`]),
+      ...(parsed.observed && Array.isArray(parsed.observed.markers) ? [] : [`${example.adapter}:${example.topic} observed.markers are required`]),
+      ...(parsed.boundary_assertions?.platform_api === false ? [] : [`${example.adapter}:${example.topic} platform_api boundary must be false`]),
+      ...(/^[a-f0-9]{64}$/i.test(parsed.export_digest || '') ? [] : [`${example.adapter}:${example.topic} export_digest must be sha256 hex`]),
+    ];
+  } catch {
+    return [`${example.adapter}:${example.topic} copy_ready_json must parse`];
+  }
+}
+
+function compactStrings(values) {
+  return (Array.isArray(values) ? values : [])
+    .map(stringValue)
+    .filter(Boolean);
+}
+
+function unique(values) {
+  return [...new Set(values)];
+}
+
+function stringValue(value) {
+  return String(value || '').trim();
+}
+
+function digestObject(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}

package/tools/vibe-runtime/runtime-platform-transcript-intake-model.mjs

@@ -0,0 +1,247 @@
+import crypto from 'node:crypto';
+
+export const platformTranscriptIntakeStage = 'P21';
+export const platformTranscriptIntakeKind = 'platform-transcript-intake';
+
+const allowedPlatforms = new Set(['claude', 'cursor', 'codex', 'opencode', 'pi', 'local', 'unknown']);
+const forbiddenTrueKeys = [
+  'platform_api',
+  'external_network',
+  'model_invocation',
+  'subagent',
+  'mcp',
+  'git',
+  'git_write',
+  'git_add',
+  'commit',
+  'push',
+  'pr',
+  'tag',
+  'worktree',
+  'command_execution',
+  'test_execution',
+  'check_execution',
+  'workflow_execution',
+  'skill_execution',
+  'runtime_action',
+  'business_source_write',
+  'source_write',
+];
+
+export function runtimePlatformTranscriptIntake({ artifact = {}, source = {} } = {}) {
+  const turns = normalizeTurns(artifact);
+  const observed = normalizeObserved(artifact.observed || {});
+  const artifactRefs = normalizeArtifactRefs(artifact.artifact_refs || artifact.artifactRefs || []);
+  const boundaries = normalizeBoundaryAssertions(artifact.boundary_assertions || artifact.boundaryAssertions || {});
+  const normalized = {
+    transcript_kind: platformTranscriptIntakeKind,
+    stage: platformTranscriptIntakeStage,
+    platform: normalizePlatform(artifact.platform),
+    source: normalizeSource(artifact.source),
+    source_file: stringValue(source.file),
+    source_digest: stringValue(source.digest),
+    turns,
+    observed,
+    artifact_refs: artifactRefs.refs,
+    boundary_assertions: boundaries.boundary_assertions,
+    export_digest: stringValue(artifact.export_digest),
+  };
+  const findings = transcriptFindings({ artifact, normalized, artifactRefs, boundaries });
+  const intake = {
+    version: 1,
+    stage: platformTranscriptIntakeStage,
+    intake_kind: platformTranscriptIntakeKind,
+    ok: findings.length === 0,
+    source_binding: {
+      file: normalized.source_file,
+      digest: normalized.source_digest,
+      export_digest: normalized.export_digest,
+    },
+    input_summary: {
+      platform: normalized.platform,
+      turn_count: turns.length,
+      command_count: observed.commands.length,
+      marker_count: observed.markers.length,
+      artifact_ref_count: artifactRefs.refs.length,
+      boundary_key_count: Object.keys(boundaries.boundary_assertions).length,
+    },
+    normalized_transcript: normalized,
+    boundary_assertions: intakeBoundaryAssertions(),
+    writes: false,
+    state_directory_created: false,
+    local_only: true,
+    deterministic: true,
+    findings,
+  };
+  return {
+    ...intake,
+    intake_digest: digestObject(intakeDigestPayload(intake)),
+  };
+}
+
+export function intakeDigestPayload(intake) {
+  return {
+    stage: intake.stage,
+    intake_kind: intake.intake_kind,
+    source_binding: intake.source_binding,
+    input_summary: intake.input_summary,
+    normalized_transcript: intake.normalized_transcript,
+    boundary_assertions: intake.boundary_assertions,
+    findings: intake.findings,
+  };
+}
+
+export function intakeBoundaryAssertions() {
+  return Object.fromEntries([
+    ['transcript_intake_artifact', false],
+    ['normalized_transcript_artifact', false],
+    ['sidecar_write', false],
+    ['state_directory_created', false],
+    ['command_execution', false],
+    ['test_execution', false],
+    ['check_execution', false],
+    ['eval_execution', false],
+    ['workflow_execution', false],
+    ['skill_execution', false],
+    ['runtime_action', false],
+    ['platform_api', false],
+    ['external_network', false],
+    ['model_invocation', false],
+    ['subagent', false],
+    ['mcp', false],
+    ['git', false],
+    ['git_write', false],
+    ['commit', false],
+    ['pr', false],
+    ['push', false],
+    ['worktree', false],
+    ['business_source_write', false],
+  ]);
+}
+
+function transcriptFindings({ artifact, normalized, artifactRefs, boundaries }) {
+  return [
+    ...(!artifact || typeof artifact !== 'object' || Array.isArray(artifact) ? ['transcript intake input must be a JSON object'] : []),
+    ...(allowedPlatforms.has(normalized.platform) ? [] : [`unsupported platform: ${normalized.platform}`]),
+    ...(normalized.turns.length > 0 ? [] : ['turns must include at least one role/content item']),
+    ...normalized.turns.flatMap((turn, index) => turnFindings(turn, index)),
+    ...normalized.observed.commands.flatMap((command, index) => boundedStringFindings(command, `observed.commands[${index}]`)),
+    ...normalized.observed.markers.flatMap((marker, index) => boundedStringFindings(marker, `observed.markers[${index}]`)),
+    ...artifactRefs.findings,
+    ...boundaries.findings,
+    ...exportDigestFindings(normalized),
+  ];
+}
+
+function normalizePlatform(value) {
+  const platform = stringValue(value || 'unknown').toLowerCase();
+  return platform || 'unknown';
+}
+
+function normalizeSource(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [stringValue(key), stringValue(item)]).filter(([key]) => key));
+}
+
+function normalizeTurns(artifact) {
+  const raw = Array.isArray(artifact.turns) ? artifact.turns : Array.isArray(artifact.transcript) ? artifact.transcript : [];
+  return raw
+    .filter((turn) => turn && typeof turn === 'object' && !Array.isArray(turn))
+    .map((turn) => ({ role: stringValue(turn.role), content: stringValue(turn.content) }))
+    .filter((turn) => turn.role || turn.content);
+}
+
+function normalizeObserved(observed) {
+  return {
+    commands: compactStrings(observed.commands),
+    markers: compactStrings(observed.markers),
+    blocked_reasons: compactStrings(observed.blocked_reasons),
+    workflow_order: compactStrings(observed.workflow_order || observed.selected_workflow),
+    claims: Array.isArray(observed.claims) ? observed.claims : [],
+  };
+}
+
+function normalizeArtifactRefs(refs) {
+  const normalized = Array.isArray(refs) ? refs.map(normalizeArtifactRef).filter(Boolean) : [];
+  return {
+    refs: normalized,
+    findings: normalized.flatMap((ref, index) => artifactRefFindings(ref, index)),
+  };
+}
+
+function normalizeArtifactRef(ref) {
+  if (!ref || typeof ref !== 'object' || Array.isArray(ref)) return null;
+  return {
+    path: normalizeSlash(ref.path || ref.file || ref.ref),
+    digest: stringValue(ref.digest || ref.sha256),
+    kind: stringValue(ref.kind || ref.artifact_kind),
+  };
+}
+
+function normalizeBoundaryAssertions(boundaries) {
+  const boundary_assertions = boundaries && typeof boundaries === 'object' && !Array.isArray(boundaries)
+    ? Object.fromEntries(Object.entries(boundaries).map(([key, value]) => [stringValue(key), value === true]))
+    : {};
+  const findings = forbiddenTrueKeys
+    .filter((key) => boundary_assertions[key] === true)
+    .map((key) => `boundary assertion must remain false: ${key}`);
+  return { boundary_assertions, findings };
+}
+
+function turnFindings(turn, index) {
+  return [
+    ...(turn.role ? [] : [`turns[${index}].role is required`]),
+    ...(turn.content ? [] : [`turns[${index}].content is required`]),
+    ...boundedStringFindings(turn.role, `turns[${index}].role`, 80),
+    ...boundedStringFindings(turn.content, `turns[${index}].content`, 20000),
+  ];
+}
+
+function artifactRefFindings(ref, index) {
+  return [
+    ...(safeRelativePath(ref.path) ? [] : [`artifact_refs[${index}].path must be a safe root-relative path`]),
+    ...(!ref.digest || /^[a-f0-9]{64}$/i.test(ref.digest) ? [] : [`artifact_refs[${index}].digest must be a sha256 hex digest`]),
+  ];
+}
+
+function exportDigestFindings(normalized) {
+  if (!normalized.export_digest) return [];
+  return /^[a-f0-9]{64}$/i.test(normalized.export_digest) ? [] : ['export_digest must be a sha256 hex digest'];
+}
+
+function boundedStringFindings(value, label, maxLength = 500) {
+  return stringValue(value).length <= maxLength ? [] : [`${label} exceeds ${maxLength} characters`];
+}
+
+function safeRelativePath(value) {
+  const normalized = normalizeSlash(value);
+  return Boolean(normalized)
+    && !normalized.startsWith('/')
+    && !/^[A-Za-z]:\//.test(normalized)
+    && !normalized.split('/').includes('..')
+    && !normalized.split('/').includes('');
+}
+
+function compactStrings(values) {
+  return (Array.isArray(values) ? values : [])
+    .map(stringValue)
+    .filter(Boolean);
+}
+
+function stringValue(value) {
+  return String(value || '').trim();
+}
+
+function normalizeSlash(value) {
+  return stringValue(value).replace(/\\/g, '/');
+}
+
+function digestObject(value) {
+  return crypto.createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}