sdd-agent-platform 0.4.2 → 0.5.1

package/node_modules/@sdd-agent-platform/core/src/run-state/artifacts.ts

@@ -1,240 +1,126 @@
-import { createHash } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { getBranchStageEvidencePathFromRef, getEvidenceAttachmentPath, getLegacyArtifactPath, getRunRelativeArtifactPath, getRuntimeStorePath, isBranchStageEvidenceRef, normalizeArtifactRootRelativePath, normalizeBranchStageEvidenceRef, toBranchStageEvidenceRef } from '../runtime-paths.js';
-import { readRuntimeRunState, recordRuntimeArtifactPayload, recordRuntimeEvidenceAttachment, resolveRuntimeArtifactPayload, runtimeScopedId, withRuntimeStore, type RuntimeArtifactPayloadRecord } from '../storage/runtime-store.js';
-import type { SddStage } from '../contracts.js';
-import { appendArtifactHashLedgerEntry } from './invocation-ledger.js';
-
-export async function writeArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string, content: string): Promise<{ absolutePath: string; runRelativePath: string }> {
-  const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
-  const runRelativePath = getRunRelativeArtifactPath(normalized);
-  const runScope = await resolveRunScope(projectRoot, runId);
-  const contentHash = hashDocumentContent(content);
-  const physicalPayloadPath = uniquePhysicalPayloadPath(runRelativePath, runId, contentHash);
-  const absolutePath = getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, physicalPayloadPath);
-  await mkdir(path.dirname(absolutePath), { recursive: true });
-  await writeFile(absolutePath, content, 'utf8');
-  await appendArtifactHashLedgerEntry(projectRoot, {
-    runId,
-    artifactPath: runRelativePath,
-    content,
-    status: 'written'
-  });
-  await recordRuntimeArtifact(projectRoot, { runId, path: runRelativePath, content, status: 'written', taskId: runScope.taskId });
-  await recordRuntimeArtifactPayload(projectRoot, {
-    payloadId: runtimeScopedId(runId, runRelativePath, contentHash),
-    runId,
-    sourceRunId: runId,
-    branchSlug: runScope.branchSlug,
-    taskId: runScope.taskId,
-    logicalRef: runRelativePath,
-    physicalPayloadPath,
-    artifactRole: artifactKind(runRelativePath),
-    digest: contentHash,
-    status: 'active',
-    payload: { logicalRef: runRelativePath, physicalPayloadPath, artifactPath: runRelativePath, status: 'written' }
-  });
-  await recordRuntimeEvidenceAttachment(projectRoot, {
-    branchSlug: runScope.branchSlug,
-    runId,
-    taskId: runScope.taskId,
-    kind: artifactKind(runRelativePath),
-    relativePath: physicalPayloadPath,
-    contentHash,
-    bytes: Buffer.byteLength(content, 'utf8'),
-    payload: { logicalRef: runRelativePath, physicalPayloadPath, status: 'written' }
-  });
-  return { absolutePath, runRelativePath };
-}
-
-export async function recordStageEvidenceArtifact(projectRoot: string, runId: string, stageEvidenceRef: string, content: string, options: { taskId?: string | null; artifactRole?: string } = {}): Promise<{ absolutePath: string; runRelativePath: string }> {
-  const runRelativePath = normalizeBranchStageEvidenceRef(stageEvidenceRef);
-  const runScope = await resolveRunScope(projectRoot, runId);
-  const taskId = options.taskId ?? runScope.taskId;
-  const contentHash = hashDocumentContent(content);
-  const absolutePath = getBranchStageEvidencePathFromRef(projectRoot, runRelativePath);
-  await mkdir(path.dirname(absolutePath), { recursive: true });
-  await writeFile(absolutePath, content, 'utf8');
-  await appendArtifactHashLedgerEntry(projectRoot, {
-    runId,
-    taskId,
-    branch: runScope.branchSlug,
-    artifactPath: runRelativePath,
-    content,
-    status: 'written'
-  });
-  await recordRuntimeArtifact(projectRoot, { runId, path: runRelativePath, content, status: 'written', taskId });
-  await recordRuntimeArtifactPayload(projectRoot, {
-    payloadId: runtimeScopedId(runId, runRelativePath, contentHash),
-    runId,
-    sourceRunId: runId,
-    branchSlug: runScope.branchSlug,
-    taskId,
-    logicalRef: runRelativePath,
-    physicalPayloadPath: runRelativePath,
-    artifactRole: options.artifactRole ?? artifactKind(runRelativePath),
-    digest: contentHash,
-    status: 'active',
-    payload: { logicalRef: runRelativePath, physicalPayloadPath: runRelativePath, storage: 'stage-evidence', status: 'written' }
-  });
-  await recordRuntimeEvidenceAttachment(projectRoot, {
-    branchSlug: runScope.branchSlug,
-    runId,
-    taskId,
-    kind: options.artifactRole ?? artifactKind(runRelativePath),
-    relativePath: runRelativePath,
-    contentHash,
-    bytes: Buffer.byteLength(content, 'utf8'),
-    payload: { logicalRef: runRelativePath, physicalPayloadPath: runRelativePath, storage: 'stage-evidence', status: 'written' }
-  });
-  return { absolutePath, runRelativePath };
-}
-
-export async function recordRuntimeOnlyArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string, content: string, options: { logicalRef?: string; branch?: string | null; taskId?: string | null; artifactRole?: string } = {}): Promise<{ absolutePath: string; runRelativePath: string }> {
-  const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
-  const runRelativePath = options.logicalRef ?? getRunRelativeArtifactPath(normalized);
-  const runScope = await resolveRunScope(projectRoot, runId);
-  const branchSlug = options.branch ?? runScope.branchSlug;
-  const taskId = options.taskId ?? runScope.taskId;
-  const contentHash = hashDocumentContent(content);
-  const physicalPayloadPath = `runtime.sqlite:${runId}:${runRelativePath}`;
-  await appendArtifactHashLedgerEntry(projectRoot, {
-    runId,
-    taskId,
-    branch: branchSlug,
-    artifactPath: runRelativePath,
-    content,
-    status: 'recorded'
-  });
-  await recordRuntimeArtifact(projectRoot, { runId, path: runRelativePath, content, status: 'recorded', taskId });
-  await recordRuntimeArtifactPayload(projectRoot, {
-    payloadId: runtimeScopedId(runId, runRelativePath, contentHash),
-    runId,
-    sourceRunId: runId,
-    branchSlug,
-    taskId,
-    logicalRef: runRelativePath,
-    physicalPayloadPath,
-    artifactRole: options.artifactRole ?? artifactKind(runRelativePath),
-    digest: contentHash,
-    status: 'active',
-    payload: { logicalRef: runRelativePath, physicalPayloadPath, storage: 'runtime.sqlite', content }
-  });
-  await recordRuntimeEvidenceAttachment(projectRoot, {
-    branchSlug,
-    runId,
-    taskId,
-    kind: options.artifactRole ?? artifactKind(runRelativePath),
-    relativePath: physicalPayloadPath,
-    contentHash,
-    bytes: Buffer.byteLength(content, 'utf8'),
-    payload: { logicalRef: runRelativePath, physicalPayloadPath, storage: 'runtime.sqlite' }
-  });
-  return { absolutePath: `${getRuntimeStorePath(projectRoot)}#${runRelativePath}`, runRelativePath };
-}
-
-export async function readArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string): Promise<string> {
-  const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
-  const runRelativePath = getRunRelativeArtifactPath(normalized);
-  const runScope = await resolveRunScope(projectRoot, runId);
-  const payload = await resolveRuntimeArtifactPayload(projectRoot, runId, runRelativePath)
-    ?? await resolveRuntimeArtifactPayload(projectRoot, runId, runtimeStageEvidenceRef(runScope.branchSlug, normalized));
-  const payloadContent = runtimePayloadContent(payload);
-  if (payloadContent !== null) {
-    return payloadContent;
-  }
-  if (payload) {
-    if (isBranchStageEvidenceRef(payload.physicalPayloadPath)) {
-      return readFile(getBranchStageEvidencePathFromRef(projectRoot, payload.physicalPayloadPath), 'utf8');
-    }
-    return readFile(getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, payload.physicalPayloadPath), 'utf8');
-  }
-  const stageEvidenceRef = runtimeStageEvidenceRef(runScope.branchSlug, normalized);
-  try {
-    return await readFile(getBranchStageEvidencePathFromRef(projectRoot, stageEvidenceRef), 'utf8');
-  } catch {
-    try {
-      return await readFile(getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, runRelativePath), 'utf8');
-    } catch {
-      return readFile(getLegacyArtifactPath(projectRoot, runId, normalized), 'utf8');
-    }
-  }
-}
-
-function runtimePayloadContent(payload: RuntimeArtifactPayloadRecord | null): string | null {
-  if (!payload || !payload.payload || typeof payload.payload !== 'object' || Array.isArray(payload.payload)) {
-    return null;
-  }
-  const content = (payload.payload as { content?: unknown }).content;
-  return typeof content === 'string' ? content : null;
-}
-
-function runtimeStageEvidenceRef(branch: string, artifactRootRelativePath: string): string {
-  const fileName = path.posix.basename(artifactRootRelativePath.replace(/\\/g, '/'));
-  return toBranchStageEvidenceRef(branch, runtimeStageForArtifact(fileName), fileName);
-}
-
-function runtimeStageForArtifact(fileName: string): SddStage {
-  if (fileName.startsWith('acceptance-coverage-')) {
-    return 'goal-verify';
-  }
-  if (fileName.startsWith('test-') || fileName.startsWith('validation-')) {
-    return 'test';
-  }
-  if (fileName.startsWith('ship-') || fileName.startsWith('release-')) {
-    return 'ship';
-  }
-  return 'do';
-}
-
-function uniquePhysicalPayloadPath(logicalRef: string, runId: string, digest: string): string {
-  const parsed = path.posix.parse(logicalRef.replace(/\\/g, '/'));
-  const suffix = `${runId}-${digest.slice(0, 12)}`;
-  return path.posix.join(parsed.dir, `${parsed.name}-${suffix}${parsed.ext}`);
-}
-
-export function artifactKind(artifactPath: string): string {
-  const fileName = path.posix.basename(artifactPath.replace(/\\/g, '/'));
-  if (fileName.startsWith('implement-')) {
-    return 'implement';
-  }
-  if (fileName.startsWith('review-')) {
-    return 'review';
-  }
-  if (fileName.startsWith('debug-')) {
-    return 'debug';
-  }
-  if (fileName.startsWith('test-validation-')) {
-    return 'test-validation';
-  }
-  if (fileName.startsWith('validation-')) {
-    return 'validation';
-  }
-  if (fileName.startsWith('gap-report-')) {
-    return 'gap-report';
-  }
-  return 'artifact';
-}
-
-async function recordRuntimeArtifact(projectRoot: string, input: { runId: string; path: string; content: string; status: string; taskId?: string | null; agent?: string | null }): Promise<void> {
-  const contentHash = hashDocumentContent(input.content);
-  const now = new Date().toISOString();
-  const payload = JSON.stringify({ path: input.path, status: input.status, taskId: input.taskId ?? null, agent: input.agent ?? null });
-  await withRuntimeStore(projectRoot, ({ db }) => {
-    db.prepare('INSERT OR REPLACE INTO artifacts (artifact_id, run_id, path, kind, task_id, agent, content_hash, bytes, status, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-      .run(runtimeScopedId(input.runId, input.path, contentHash), input.runId, input.path, artifactKind(input.path), input.taskId ?? null, input.agent ?? null, contentHash, Buffer.byteLength(input.content, 'utf8'), input.status, now, payload);
-  });
-}
-
-async function resolveRunScope(projectRoot: string, runId: string): Promise<{ branchSlug: string; taskId: string | null }> {
-  const state = await readRuntimeRunState(projectRoot, runId);
-  return {
-    branchSlug: state?.gitBranch ?? state?.partition ?? 'unscoped',
-    taskId: state?.taskId ?? state?.currentTask ?? null
-  };
-}
-
-function hashDocumentContent(raw: string): string {
-  return createHash('sha256').update(raw.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
-}
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getEvidenceAttachmentPath, getLegacyArtifactPath, getRunRelativeArtifactPath, normalizeArtifactRootRelativePath } from '../runtime-paths.js';
+import { readRuntimeRunState, recordRuntimeArtifactPayload, recordRuntimeEvidenceAttachment, resolveRuntimeArtifactPayload, runtimeScopedId, withRuntimeStore } from '../storage/runtime-store.js';
+import { appendArtifactHashLedgerEntry } from './invocation-ledger.js';
+
+export async function writeArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string, content: string): Promise<{ absolutePath: string; runRelativePath: string }> {
+  const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
+  const runRelativePath = getRunRelativeArtifactPath(normalized);
+  const runScope = await resolveRunScope(projectRoot, runId);
+  const contentHash = hashDocumentContent(content);
+  const physicalPayloadPath = uniquePhysicalPayloadPath(runRelativePath, runId, contentHash);
+  const absolutePath = getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, physicalPayloadPath);
+  await mkdir(path.dirname(absolutePath), { recursive: true });
+  await writeFile(absolutePath, content, 'utf8');
+  await appendArtifactHashLedgerEntry(projectRoot, {
+    runId,
+    artifactPath: runRelativePath,
+    content,
+    status: 'written'
+  });
+  await recordRuntimeArtifact(projectRoot, { runId, path: runRelativePath, content, status: 'written', taskId: runScope.taskId });
+  await recordRuntimeArtifactPayload(projectRoot, {
+    payloadId: runtimeScopedId(runId, runRelativePath, contentHash),
+    runId,
+    sourceRunId: runId,
+    branchSlug: runScope.branchSlug,
+    taskId: runScope.taskId,
+    logicalRef: runRelativePath,
+    physicalPayloadPath,
+    artifactRole: artifactKind(runRelativePath),
+    digest: contentHash,
+    status: 'active',
+    payload: { logicalRef: runRelativePath, physicalPayloadPath, artifactPath: runRelativePath, status: 'written' }
+  });
+  await recordRuntimeEvidenceAttachment(projectRoot, {
+    branchSlug: runScope.branchSlug,
+    runId,
+    taskId: runScope.taskId,
+    kind: artifactKind(runRelativePath),
+    relativePath: physicalPayloadPath,
+    contentHash,
+    bytes: Buffer.byteLength(content, 'utf8'),
+    payload: { logicalRef: runRelativePath, physicalPayloadPath, status: 'written' }
+  });
+  return { absolutePath, runRelativePath };
+}
+
+export async function recordRuntimeOnlyArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string, content: string, _metadata: { logicalRef?: string; branch?: string; taskId?: string; artifactRole?: string } = {}): Promise<{ absolutePath: string; runRelativePath: string }> {
+  return writeArtifact(projectRoot, runId, artifactRootRelativePath, content);
+}
+
+export async function recordStageEvidenceArtifact(projectRoot: string, runId: string, stageEvidenceRef: string, content: string, _metadata: { taskId?: string; artifactRole?: string } = {}): Promise<{ absolutePath: string; runRelativePath: string }> {
+  return writeArtifact(projectRoot, runId, stageEvidenceRef, content);
+}
+
+export async function readArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string): Promise<string> {
+  const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
+  const runRelativePath = getRunRelativeArtifactPath(normalized);
+  const payload = await resolveRuntimeArtifactPayload(projectRoot, runId, runRelativePath);
+  const runScope = await resolveRunScope(projectRoot, runId);
+  const evidencePath = getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, payload?.physicalPayloadPath ?? runRelativePath);
+  if (payload) {
+    return readFile(evidencePath, 'utf8');
+  }
+  try {
+    return await readFile(evidencePath, 'utf8');
+  } catch {
+    return readFile(getLegacyArtifactPath(projectRoot, runId, normalized), 'utf8');
+  }
+}
+
+function uniquePhysicalPayloadPath(logicalRef: string, runId: string, digest: string): string {
+  const parsed = path.posix.parse(logicalRef.replace(/\\/g, '/'));
+  const suffix = `${runId}-${digest.slice(0, 12)}`;
+  return path.posix.join(parsed.dir, `${parsed.name}-${suffix}${parsed.ext}`);
+}
+
+export function artifactKind(artifactPath: string): string {
+  const fileName = path.posix.basename(artifactPath.replace(/\\/g, '/'));
+  if (fileName.startsWith('implement-')) {
+    return 'implement';
+  }
+  if (fileName.startsWith('review-')) {
+    return 'review';
+  }
+  if (fileName.startsWith('debug-')) {
+    return 'debug';
+  }
+  if (fileName.startsWith('test-validation-')) {
+    return 'test-validation';
+  }
+  if (fileName.startsWith('validation-')) {
+    return 'validation';
+  }
+  if (fileName.startsWith('gap-report-')) {
+    return 'gap-report';
+  }
+  if (fileName === 'sync-back-proposal.md') {
+    return 'sync-back-proposal';
+  }
+  return 'artifact';
+}
+
+async function recordRuntimeArtifact(projectRoot: string, input: { runId: string; path: string; content: string; status: string; taskId?: string | null; agent?: string | null }): Promise<void> {
+  const contentHash = hashDocumentContent(input.content);
+  const now = new Date().toISOString();
+  const payload = JSON.stringify({ path: input.path, status: input.status, taskId: input.taskId ?? null, agent: input.agent ?? null });
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO artifacts (artifact_id, run_id, path, kind, task_id, agent, content_hash, bytes, status, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(runtimeScopedId(input.runId, input.path, contentHash), input.runId, input.path, artifactKind(input.path), input.taskId ?? null, input.agent ?? null, contentHash, Buffer.byteLength(input.content, 'utf8'), input.status, now, payload);
+  });
+}
+
+async function resolveRunScope(projectRoot: string, runId: string): Promise<{ branchSlug: string; taskId: string | null }> {
+  const state = await readRuntimeRunState(projectRoot, runId);
+  return {
+    branchSlug: state?.gitBranch ?? state?.partition ?? 'unscoped',
+    taskId: state?.taskId ?? state?.currentTask ?? null
+  };
+}
+
+function hashDocumentContent(raw: string): string {
+  return createHash('sha256').update(raw.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
+}

package/node_modules/@sdd-agent-platform/core/src/run-state/events.ts

@@ -1,27 +1,27 @@
-
-import path from 'node:path';
-import { EVENT_LOG_CONTRACT } from '../contracts.js';
-import { getLegacyRunDir } from '../runtime-paths.js';
-
-import { importLegacyRunEventsIfNeeded, readRuntimeRunEvents, recordRuntimeEvent } from '../storage/runtime-store.js';
-import type { RuntimeEvent } from './model.js';
-
-export async function appendEvent(projectRoot: string, runId: string, event: Omit<RuntimeEvent, 'contract' | 'time'>): Promise<RuntimeEvent> {
-  const nextEvent: RuntimeEvent = {
-    contract: EVENT_LOG_CONTRACT,
-    time: new Date().toISOString(),
-    ...event
-  };
-  await recordRuntimeEvent(projectRoot, nextEvent);
-  return nextEvent;
-}
-
-export async function readRunEvents(projectRoot: string, runId: string): Promise<RuntimeEvent[]> {
-  const storedEvents = await readRuntimeRunEvents(projectRoot, runId);
-  if (storedEvents.length > 0) {
-    return storedEvents;
-  }
-  const eventPath = path.join(getLegacyRunDir(projectRoot, runId), 'events.jsonl');
-  await importLegacyRunEventsIfNeeded(projectRoot, runId, eventPath);
-  return readRuntimeRunEvents(projectRoot, runId);
-}
+
+import path from 'node:path';
+import { EVENT_LOG_CONTRACT } from '../contracts.js';
+import { getLegacyRunDir } from '../runtime-paths.js';
+
+import { importLegacyRunEventsIfNeeded, readRuntimeRunEvents, recordRuntimeEvent } from '../storage/runtime-store.js';
+import type { RuntimeEvent } from './model.js';
+
+export async function appendEvent(projectRoot: string, runId: string, event: Omit<RuntimeEvent, 'contract' | 'time'>): Promise<RuntimeEvent> {
+  const nextEvent: RuntimeEvent = {
+    contract: EVENT_LOG_CONTRACT,
+    time: new Date().toISOString(),
+    ...event
+  };
+  await recordRuntimeEvent(projectRoot, nextEvent);
+  return nextEvent;
+}
+
+export async function readRunEvents(projectRoot: string, runId: string): Promise<RuntimeEvent[]> {
+  const storedEvents = await readRuntimeRunEvents(projectRoot, runId);
+  if (storedEvents.length > 0) {
+    return storedEvents;
+  }
+  const eventPath = path.join(getLegacyRunDir(projectRoot, runId), 'events.jsonl');
+  await importLegacyRunEventsIfNeeded(projectRoot, runId, eventPath);
+  return readRuntimeRunEvents(projectRoot, runId);
+}