@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-sdd-handoff-chain-model.mjs

@@ -0,0 +1,168 @@
+import crypto from 'node:crypto';
+
+export const sddHandoffChainKind = 'superpowers-parity-sdd-handoff-chain';
+
+export function sddHandoffChainTemplate({ stage, writes = false } = {}) {
+  const core = {
+    version: 1,
+    stage,
+    chain_kind: sddHandoffChainKind,
+    automation_profile: 'superpowers-parity',
+    order: chainOrder(),
+    required_before_next_task: requiredBeforeNextTask(),
+    allowed_sidecar_root: 'sdd',
+    sidecar_write_scope: writes ? ['sdd/**'] : [],
+    forbidden_actions: forbiddenActions(),
+    boundary_assertions: boundaryAssertions(writes),
+    writes: Boolean(writes),
+    sidecar_directory_created: Boolean(writes),
+    local_only: true,
+    deterministic: true,
+  };
+  return withDigest(core);
+}
+
+export function sddHandoffChainForTask({
+  stage,
+  plan,
+  task,
+  taskBrief = null,
+  adapterArtifacts = [],
+  implementerReport = null,
+  evidenceChain = null,
+  reviewPackage = null,
+  reviewResult = null,
+  progressLedger = null,
+  writes = false,
+} = {}) {
+  const steps = handoffSteps({ plan, taskBrief, adapterArtifacts, implementerReport, evidenceChain, reviewPackage, reviewResult, progressLedger });
+  const core = {
+    ...sddHandoffChainTemplate({ stage, writes }),
+    source_plan: plan?.source_plan || '',
+    source_plan_digest: plan?.source_plan_digest || '',
+    task_id: task?.task_id || taskBrief?.task_id || implementerReport?.task_id || reviewResult?.task_id || '',
+    title: task?.title || '',
+    steps,
+    complete_for_next_task: steps.every((step) => step.optional || step.status === 'bound'),
+    missing_steps: steps.filter((step) => !step.optional && step.status !== 'bound').map((step) => step.id),
+  };
+  const { handoff_chain_digest: _templateDigest, ...payload } = core;
+  return withDigest(payload);
+}
+
+export function compactSddHandoffChain(chain) {
+  return {
+    chain_kind: chain?.chain_kind || sddHandoffChainKind,
+    task_id: chain?.task_id || '',
+    source_plan_digest: chain?.source_plan_digest || '',
+    complete_for_next_task: Boolean(chain?.complete_for_next_task),
+    missing_steps: Array.isArray(chain?.missing_steps) ? chain.missing_steps : [],
+    handoff_chain_digest: chain?.handoff_chain_digest || '',
+  };
+}
+
+function handoffSteps(input) {
+  return [
+    planStep(input.plan),
+    taskBriefStep(input.taskBrief),
+    adapterStep(input.adapterArtifacts),
+    implementerReportStep(input.implementerReport),
+    evidenceStep(input.evidenceChain),
+    reviewPackageStep(input.reviewPackage),
+    reviewResultStep(input.reviewResult),
+    progressLedgerStep(input.progressLedger),
+  ];
+}
+
+function planStep(plan) {
+  return step('plan', 'implementation-plan', plan?.source_plan, plan?.source_plan_digest);
+}
+
+function taskBriefStep(brief) {
+  return step('task-brief', 'superpowers-parity-sdd-task-brief', brief?.brief_file || brief?.file, brief?.brief_digest || brief?.digest, { sidecar_file: brief?.sidecar_file || brief?.artifact_file || '' });
+}
+
+function adapterStep(items) {
+  const artifacts = Array.isArray(items) ? items : [];
+  return step('adapter-artifacts', 'subagent-adapter-dispatch', '', '', {
+    status: artifacts.length > 0 ? 'bound' : 'missing',
+    count: artifacts.length,
+    digests: artifacts.map((item) => item.dispatch_digest || item.digest || '').filter(Boolean),
+  });
+}
+
+function implementerReportStep(report) {
+  return step('implementer-report', 'sdd-implementer-report', report?.file || report?.report_artifact, report?.digest || report?.report_digest, { status_text: report?.status || '' });
+}
+
+function evidenceStep(chain) {
+  return step('evidence-chain', 'superpowers-parity-sdd-evidence-chain', chain?.file || chain?.evidence_chain_file, chain?.digest || chain?.evidence_chain_digest);
+}
+
+function reviewPackageStep(review) {
+  return step('review-package', 'superpowers-parity-sdd-review-package', review?.package_file || review?.file, review?.review_package_digest || review?.digest, { sidecar_file: review?.sidecar_file || '' });
+}
+
+function reviewResultStep(result) {
+  return step('review-result', 'adapter-review-result', result?.file, result?.digest, { verdict: result?.verdict || result?.review_status || '' });
+}
+
+function progressLedgerStep(ledger) {
+  return step('progress-ledger', 'sdd-progress-ledger', ledger?.file || 'sdd/progress.json', ledger?.progress_digest || ledger?.digest);
+}
+
+function step(id, artifactKind, file, digestValue, extra = {}) {
+  const status = extra.status || (digestValue ? 'bound' : 'missing');
+  const { status: _status, ...rest } = extra;
+  return { id, artifact_kind: artifactKind, file: file || '', digest: digestValue || '', status, optional: false, ...rest };
+}
+
+function chainOrder() {
+  return ['plan', 'task-brief', 'adapter-artifacts', 'implementer-report', 'evidence-chain', 'review-package', 'review-result', 'progress-ledger'];
+}
+
+function requiredBeforeNextTask() {
+  return ['plan digest', 'task brief digest', 'adapter artifact digest', 'DONE implementer report', 'evidence chain digest', 'review package digest', 'clean review result', 'progress ledger digest'];
+}
+
+function forbiddenActions() {
+  return ['source write', 'business source write', 'git add/commit/push', 'worktree creation', 'PR or merge', 'platform API call', 'model invocation', 'runtime subagent invocation', 'hidden execution'];
+}
+
+function boundaryAssertions(writes) {
+  return {
+    sdd_handoff_chain: true,
+    sdd_sidecar_write_scope: writes ? 'sdd/**' : '',
+    source_write: false,
+    business_source_write: false,
+    command_execution: false,
+    test_execution: false,
+    workflow_execution: false,
+    skill_execution: false,
+    auto_execution: false,
+    platform_api: false,
+    external_network: false,
+    model_invocation: false,
+    subagent: false,
+    git_write: false,
+    commit: false,
+    push: false,
+    pr: false,
+    merge: false,
+    worktree: false,
+  };
+}
+
+function withDigest(value) {
+  return { ...value, handoff_chain_digest: digest(value) };
+}
+
+function digest(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-sdd-implementer-artifact-model.mjs

@@ -0,0 +1,90 @@
+import crypto from 'node:crypto';
+
+export const sddImplementerReportKind = 'sdd-implementer-report';
+export const sddImplementerReportDirectoryName = 'reports';
+export const sddImplementerReportStatuses = Object.freeze(['DONE', 'QUESTIONS', 'BLOCKED']);
+
+export function checkSddImplementerReportArtifact({ report, textDigest, plan, task, taskBriefDigest, requireDone = false }) {
+  const findings = [];
+  if (!report || typeof report !== 'object' || Array.isArray(report)) {
+    return blocked(['sdd implementer report must be a JSON object']);
+  }
+  if (report.artifact_kind !== sddImplementerReportKind) findings.push(`sdd implementer report artifact_kind must be ${sddImplementerReportKind}`);
+  if (report.task_id !== task.task_id) findings.push('sdd implementer report task id mismatch');
+  if (report.source_plan_digest && report.source_plan_digest !== plan.source_plan_digest) findings.push('sdd implementer report plan digest drift');
+  if (report.brief_digest !== taskBriefDigest) findings.push('sdd implementer report brief digest mismatch');
+  const status = normalizedStatus(report.status);
+  if (!status) findings.push('sdd implementer report status must be DONE, QUESTIONS, or BLOCKED');
+  if (!Array.isArray(report.commits)) findings.push('sdd implementer report commits must be an array');
+  if (!Array.isArray(report.concerns)) findings.push('sdd implementer report concerns must be an array');
+  if (!Array.isArray(report.questions)) findings.push('sdd implementer report questions must be an array');
+  if (!hasObject(report.tests)) findings.push('sdd implementer report tests must be an object');
+  if (!hasObject(report.self_review)) findings.push('sdd implementer report self_review must be an object');
+  if (status === 'DONE') {
+    if (!hasSummary(report.tests)) findings.push('sdd implementer report DONE requires test summary');
+    if (!hasSummary(report.self_review)) findings.push('sdd implementer report DONE requires self-review summary');
+  }
+  if (requireDone && status !== 'DONE') findings.push('sdd implementer report must be DONE before review package creation');
+  const normalized = {
+    artifact_kind: report.artifact_kind || '',
+    task_id: report.task_id || '',
+    status: status || String(report.status || ''),
+    source_plan_digest: report.source_plan_digest || '',
+    brief_digest: report.brief_digest || '',
+    commits: Array.isArray(report.commits) ? report.commits : [],
+    tests: hasObject(report.tests) ? report.tests : null,
+    self_review: hasObject(report.self_review) ? report.self_review : null,
+    concerns: Array.isArray(report.concerns) ? report.concerns : [],
+    questions: Array.isArray(report.questions) ? report.questions : [],
+    digest: textDigest || '',
+  };
+  return {
+    ok: findings.length === 0,
+    status: normalized.status,
+    normalized,
+    findings,
+    clean_review_eligible: findings.length === 0 && status === 'DONE',
+  };
+}
+
+export function sddImplementerReportSummary(validation) {
+  const report = validation.normalized || {};
+  return {
+    status: validation.status || '',
+    digest: report.digest || '',
+    commits_count: Array.isArray(report.commits) ? report.commits.length : 0,
+    tests: report.tests || null,
+    self_review: report.self_review || null,
+    concerns_count: Array.isArray(report.concerns) ? report.concerns.length : 0,
+    questions_count: Array.isArray(report.questions) ? report.questions.length : 0,
+    clean_review_eligible: Boolean(validation.clean_review_eligible),
+  };
+}
+
+export function sddImplementerReportTextDigest(text) {
+  return crypto.createHash('sha256').update(String(text || '')).digest('hex');
+}
+
+function blocked(findings) {
+  return {
+    ok: false,
+    status: '',
+    normalized: {},
+    findings,
+    clean_review_eligible: false,
+  };
+}
+
+function normalizedStatus(value) {
+  const status = String(value || '').toUpperCase();
+  return sddImplementerReportStatuses.includes(status) ? status : '';
+}
+
+function hasObject(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function hasSummary(value) {
+  if (!hasObject(value)) return false;
+  return typeof value.summary === 'string' && value.summary.trim().length > 0;
+}