@tea-agent/loop-agent 0.31.1 → 0.32.0

package/dist/worker/materialize/harness-task-lineage.js

@@ -0,0 +1,220 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
+import { resolveLoopAgentProfile } from "../profile-mapping.js";
+import { mapRiskLevelToComplexity } from "../task-spec/complexity-mapping.js";
+import { resolveWorkflow, } from "../task-spec/workflow-routing.js";
+export const HARNESS_TASK_LINEAGE_MATERIALIZATION_VERSION = 1;
+export const MAX_HARNESS_TASK_ID_LENGTH = 96;
+export function slugifyIdentity(value) {
+    return value
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+export function buildHarnessTaskLineage(taskSpec) {
+    const lineageId = slugifyIdentity(`${taskSpec.feature_id}-${taskSpec.id}`);
+    return {
+        schemaVersion: 1,
+        featureId: taskSpec.feature_id,
+        taskId: taskSpec.id,
+        lineageId,
+    };
+}
+export function isLegacyReadableHarnessTaskId(taskId) {
+    return /^\d{4}-\d{2}-\d{2}-[a-z0-9]+(-[a-z0-9]+)*$/.test(taskId);
+}
+export function buildHarnessTaskId(lineageId, revisionId) {
+    const revisionShort = revisionId.slice(0, 8);
+    let base = `${lineageId}--${revisionShort}`;
+    if (base.length <= MAX_HARNESS_TASK_ID_LENGTH) {
+        return base;
+    }
+    const hash = createHash("sha256")
+        .update(`${lineageId}:${revisionId}`)
+        .digest("hex")
+        .slice(0, 8);
+    const prefixBudget = MAX_HARNESS_TASK_ID_LENGTH - hash.length - 2;
+    const prefix = lineageId.slice(0, Math.max(8, prefixBudget)).replace(/-+$/g, "");
+    base = `${prefix}--${hash}`;
+    if (base.length > MAX_HARNESS_TASK_ID_LENGTH) {
+        throw new Error(`harness task id exceeds bounded length (${base.length} > ${MAX_HARNESS_TASK_ID_LENGTH})`);
+    }
+    return base;
+}
+/** Legacy date+title slug ids remain readable; new ids never depend on title. */
+export function buildLegacyReadableHarnessTaskId(taskSpec, now) {
+    const date = now.toISOString().slice(0, 10);
+    const slug = slugifyIdentity(`${taskSpec.id}-${taskSpec.title}`);
+    return `${date}-${slug}`;
+}
+export async function computeSourceRefHashes(input) {
+    const taskSpecDir = path.dirname(path.resolve(input.taskSpecPath));
+    const hashes = {};
+    for (const [key, relativePath] of Object.entries(input.taskSpec.source_docs)) {
+        if (!relativePath)
+            continue;
+        const sourcePath = path.resolve(taskSpecDir, relativePath);
+        const content = await readFile(sourcePath);
+        hashes[key] = createHash("sha256").update(content).digest("hex");
+    }
+    return hashes;
+}
+export function computeRevisionDigests(input) {
+    const sourcePayload = {
+        materializationVersion: HARNESS_TASK_LINEAGE_MATERIALIZATION_VERSION,
+        source_docs: input.taskSpec.source_docs,
+        source_ref_hashes: input.sourceRefHashes,
+    };
+    const sourceDigest = sha256OfCanonicalJson(sourcePayload);
+    const contractPayload = {
+        materializationVersion: HARNESS_TASK_LINEAGE_MATERIALIZATION_VERSION,
+        id: input.taskSpec.id,
+        feature_id: input.taskSpec.feature_id,
+        repo: input.taskSpec.repo,
+        type: input.taskSpec.type,
+        priority: input.taskSpec.priority,
+        risk_level: input.taskSpec.risk_level,
+        capabilities: input.taskSpec.capabilities ?? [],
+        depends_on: input.taskSpec.depends_on,
+        acceptance_refs: input.taskSpec.acceptance_refs,
+        scope: input.taskSpec.scope,
+        constraints: input.taskSpec.constraints,
+        verify: input.taskSpec.verify,
+        worker: input.taskSpec.worker,
+        execution: input.taskSpec.execution,
+        loop_agent: input.taskSpec.loop_agent,
+        outputs: input.taskSpec.outputs,
+        failure_policy: input.taskSpec.failure_policy,
+        workflow: input.workflow,
+        taskKind: input.taskKind,
+        loopAgentProfile: input.loopAgentProfile,
+        allowedPaths: [...input.allowedPaths].sort(),
+        complexity: mapRiskLevelToComplexity(input.taskSpec.risk_level),
+    };
+    const contractDigest = sha256OfCanonicalJson(contractPayload);
+    const revisionId = sha256OfCanonicalJson({
+        sourceDigest,
+        contractDigest,
+    });
+    return { sourceDigest, contractDigest, revisionId };
+}
+export async function resolveRevisionDigestsForTaskSpec(input) {
+    const resolvedWorkflow = resolveWorkflow(input.taskSpec);
+    const profileMapping = resolveLoopAgentProfile(input.taskSpec);
+    const allowedPaths = expandAllowedPathsForWorkflow(resolvedWorkflow.workflow, input.taskSpec.constraints.allowed_paths);
+    const sourceRefHashes = await computeSourceRefHashes({
+        taskSpec: input.taskSpec,
+        taskSpecPath: input.taskSpecPath,
+    });
+    const digests = computeRevisionDigests({
+        taskSpec: input.taskSpec,
+        workflow: resolvedWorkflow.workflow,
+        taskKind: resolvedWorkflow.taskKind,
+        loopAgentProfile: profileMapping.loopAgentProfile,
+        allowedPaths,
+        sourceRefHashes,
+    });
+    return {
+        lineage: buildHarnessTaskLineage(input.taskSpec),
+        digests,
+        workflow: resolvedWorkflow.workflow,
+        taskKind: resolvedWorkflow.taskKind,
+        loopAgentProfile: profileMapping.loopAgentProfile,
+        allowedPaths,
+    };
+}
+/** Union TaskSpec allowed_paths with workflow-owned write roots. */
+export function expandAllowedPathsForWorkflow(workflow, allowedPaths) {
+    const extras = workflow === "backend-test"
+        ? ["testcase/**", "docs/test-reports/**"]
+        : workflow === "frontend-test"
+            ? ["testcase/frontend/**", "docs/test-reports/**"]
+            : [];
+    return Array.from(new Set([...allowedPaths, ...extras]));
+}
+export function parseLineageRevisionManifest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.schemaVersion !== 1)
+        return undefined;
+    const lineage = record.lineage;
+    const revision = record.revision;
+    if (!lineage || typeof lineage !== "object" || !revision || typeof revision !== "object") {
+        return undefined;
+    }
+    const lineageRecord = lineage;
+    const revisionRecord = revision;
+    if (lineageRecord.schemaVersion !== 1 ||
+        revisionRecord.schemaVersion !== 1 ||
+        typeof record.harnessTaskId !== "string" ||
+        typeof lineageRecord.lineageId !== "string" ||
+        typeof revisionRecord.revisionId !== "string" ||
+        typeof revisionRecord.sourceDigest !== "string" ||
+        typeof revisionRecord.contractDigest !== "string" ||
+        typeof revisionRecord.createdAt !== "string") {
+        return undefined;
+    }
+    return {
+        schemaVersion: 1,
+        lineage: {
+            schemaVersion: 1,
+            featureId: String(lineageRecord.featureId),
+            taskId: String(lineageRecord.taskId),
+            lineageId: String(lineageRecord.lineageId),
+        },
+        revision: {
+            schemaVersion: 1,
+            lineageId: String(revisionRecord.lineageId),
+            revisionId: String(revisionRecord.revisionId),
+            sourceDigest: String(revisionRecord.sourceDigest),
+            contractDigest: String(revisionRecord.contractDigest),
+            createdAt: String(revisionRecord.createdAt),
+        },
+        harnessTaskId: record.harnessTaskId,
+        ...(typeof record.previousRevisionId === "string"
+            ? { previousRevisionId: record.previousRevisionId }
+            : {}),
+        ...(typeof record.legacyReadableId === "string"
+            ? { legacyReadableId: record.legacyReadableId }
+            : {}),
+    };
+}
+export function parseLineageIndex(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.schemaVersion !== 1 ||
+        typeof record.lineageId !== "string" ||
+        typeof record.featureId !== "string" ||
+        typeof record.taskId !== "string" ||
+        typeof record.currentRevisionId !== "string" ||
+        !Array.isArray(record.revisions)) {
+        return undefined;
+    }
+    const revisions = record.revisions
+        .filter((entry) => entry && typeof entry === "object")
+        .map((entry) => {
+        const revision = entry;
+        return {
+            revisionId: String(revision.revisionId),
+            harnessTaskId: String(revision.harnessTaskId),
+            sourceDigest: String(revision.sourceDigest),
+            contractDigest: String(revision.contractDigest),
+            createdAt: String(revision.createdAt),
+        };
+    });
+    return {
+        schemaVersion: 1,
+        lineageId: record.lineageId,
+        featureId: record.featureId,
+        taskId: record.taskId,
+        currentRevisionId: record.currentRevisionId,
+        revisions,
+    };
+}