project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/legacy-sdlc-migration.js

@@ -1,199 +0,0 @@
-import path from "node:path";
-import { LEGACY_HARNESS_JSON_CONFIG_PATH, readHarnessRootConfigCandidates, } from "./harness-root.js";
-import { pathExists, readText, writeTextIfChanged } from "./fs.js";
-import { detectLegacyManagedDirectory } from "./legacy-managed-scan.js";
-import { HARNESS_JSON_CONFIG_PATH } from "./paths.js";
-const LEGACY_MANAGED_ROOT = "pjsdlc_managed";
-const CURRENT_MANAGED_ROOT = "ty-context-managed";
-const LEGACY_MAKEFILE = "sdlc-harness.mk";
-const CURRENT_MAKEFILE = "ty-context.mk";
-export const legacySdlcHarnessMigration = {
-    id: "legacy-sdlc-harness-rename",
-    introducedIn: "0.2.54",
-    description: "Rename legacy sdlc-harness configuration and pjsdlc_managed package-managed paths.",
-    scope: "package.json, sdlc-harness.config.json, <harnessRoot>/config.yaml, old managed markers and pjsdlc_managed/**",
-    risk: "safe",
-    manualMessage: "Resolve legacy sdlc-harness conflicts or move old override rules into standalone project-local Skills.",
-    detect: detectLegacySdlcHarness,
-    apply: migrateLegacySdlcHarness,
-    verify: async () => undefined,
-};
-async function detectLegacySdlcHarness(projectRoot, root, migration) {
-    const items = [];
-    const candidates = await readHarnessRootConfigCandidates(projectRoot);
-    const currentCandidates = candidates.filter((candidate) => !candidate.legacy);
-    const legacyCandidates = candidates.filter((candidate) => candidate.legacy);
-    const currentRoot = currentCandidates[0]?.harnessFolderName;
-    const distinctLegacyRoots = Array.from(new Set(legacyCandidates.map((candidate) => candidate.harnessFolderName)));
-    if (currentRoot &&
-        distinctLegacyRoots.some((legacyRoot) => legacyRoot !== currentRoot)) {
-        items.push(item(migration, "blocked", rootConflictPath(currentCandidates, legacyCandidates), "Current ty-context and legacy sdlc-harness root configuration disagree; choose the harness root manually before upgrade."));
-    }
-    else if (!currentRoot && distinctLegacyRoots.length > 1) {
-        items.push(item(migration, "blocked", rootConflictPath(currentCandidates, legacyCandidates), "Legacy sdlc-harness root sources disagree; choose one harness root manually before upgrade."));
-    }
-    items.push(...(await detectLegacyManagedDirectory(projectRoot, root, legacySdlcHarnessMigration)));
-    if (items.some((entry) => entry.status === "blocked")) {
-        return items;
-    }
-    if (await needsLegacySafeMigration(projectRoot, root, legacyCandidates.length > 0)) {
-        items.unshift(item(migration, "safe_pending", "legacy sdlc-harness surfaces", "Legacy sdlc-harness naming can be copied to ty-context configuration and refreshed by sync."));
-    }
-    return items;
-}
-async function migrateLegacySdlcHarness(projectRoot, root, report) {
-    await migratePackageJsonConfig(projectRoot, report);
-    await migrateJsonConfig(projectRoot, report);
-    await migrateConfigYamlPaths(projectRoot, root, report);
-}
-async function needsLegacySafeMigration(projectRoot, root, hasLegacyRootConfig) {
-    if (hasLegacyRootConfig &&
-        (await legacyPackageConfigNeedsCopy(projectRoot))) {
-        return true;
-    }
-    if (await legacyJsonConfigNeedsCopy(projectRoot)) {
-        return true;
-    }
-    if (await configYamlHasLegacyManagedPaths(projectRoot, root)) {
-        return true;
-    }
-    if (await hasLegacyManagedMarkers(projectRoot)) {
-        return true;
-    }
-    return false;
-}
-async function legacyPackageConfigNeedsCopy(projectRoot) {
-    const packagePath = path.join(projectRoot, "package.json");
-    if (!(await pathExists(packagePath))) {
-        return false;
-    }
-    const packageJson = parseJsonRecord(await readText(packagePath), "package.json");
-    return (isJsonRecord(packageJson.sdlcHarness) &&
-        !isJsonRecord(packageJson.tyContext));
-}
-async function legacyJsonConfigNeedsCopy(projectRoot) {
-    const legacyPath = path.join(projectRoot, LEGACY_HARNESS_JSON_CONFIG_PATH);
-    const currentPath = path.join(projectRoot, HARNESS_JSON_CONFIG_PATH);
-    return (await pathExists(legacyPath)) && !(await pathExists(currentPath));
-}
-async function configYamlHasLegacyManagedPaths(projectRoot, root) {
-    const configPath = path.join(projectRoot, root, "config.yaml");
-    if (!(await pathExists(configPath))) {
-        return false;
-    }
-    return hasLegacyManagedPath(await readText(configPath));
-}
-async function hasLegacyManagedMarkers(projectRoot) {
-    for (const relative of [
-        "AGENTS.md",
-        "Makefile",
-        ".github/workflows/harness.yml",
-    ]) {
-        const target = path.join(projectRoot, ...relative.split("/"));
-        if ((await pathExists(target)) && hasLegacyMarker(await readText(target))) {
-            return true;
-        }
-    }
-    return false;
-}
-async function migratePackageJsonConfig(projectRoot, report) {
-    const packagePath = path.join(projectRoot, "package.json");
-    if (!(await pathExists(packagePath))) {
-        report.skipped.push("package.json#sdlcHarness");
-        return;
-    }
-    const packageJson = parseJsonRecord(await readText(packagePath), "package.json");
-    if (!isJsonRecord(packageJson.sdlcHarness) ||
-        isJsonRecord(packageJson.tyContext)) {
-        report.skipped.push("package.json#sdlcHarness");
-        return;
-    }
-    packageJson.tyContext = { ...packageJson.sdlcHarness };
-    if (await writeTextIfChanged(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`)) {
-        report.changed.push("package.json#tyContext");
-    }
-    else {
-        report.skipped.push("package.json#tyContext");
-    }
-}
-async function migrateJsonConfig(projectRoot, report) {
-    const legacyPath = path.join(projectRoot, LEGACY_HARNESS_JSON_CONFIG_PATH);
-    const currentPath = path.join(projectRoot, HARNESS_JSON_CONFIG_PATH);
-    if (!(await pathExists(legacyPath))) {
-        report.skipped.push(LEGACY_HARNESS_JSON_CONFIG_PATH);
-        return;
-    }
-    if (await pathExists(currentPath)) {
-        report.skipped.push(HARNESS_JSON_CONFIG_PATH);
-        return;
-    }
-    if (await writeTextIfChanged(currentPath, await readText(legacyPath))) {
-        report.changed.push(HARNESS_JSON_CONFIG_PATH);
-    }
-    else {
-        report.skipped.push(HARNESS_JSON_CONFIG_PATH);
-    }
-}
-async function migrateConfigYamlPaths(projectRoot, root, report) {
-    const relative = `${root}/config.yaml`;
-    const configPath = path.join(projectRoot, root, "config.yaml");
-    if (!(await pathExists(configPath))) {
-        report.skipped.push(relative);
-        return;
-    }
-    const original = await readText(configPath);
-    const next = rewriteLegacyManagedPaths(original);
-    if (next === original) {
-        report.skipped.push(relative);
-        return;
-    }
-    if (await writeTextIfChanged(configPath, next)) {
-        report.changed.push(`${relative}#legacy-managed-paths`);
-    }
-    else {
-        report.skipped.push(`${relative}#legacy-managed-paths`);
-    }
-}
-function rewriteLegacyManagedPaths(content) {
-    return content
-        .replaceAll(LEGACY_MANAGED_ROOT, CURRENT_MANAGED_ROOT)
-        .replaceAll(LEGACY_MAKEFILE, CURRENT_MAKEFILE);
-}
-function hasLegacyManagedPath(content) {
-    return (content.includes(LEGACY_MANAGED_ROOT) || content.includes(LEGACY_MAKEFILE));
-}
-function hasLegacyMarker(content) {
-    return [
-        "<!-- pjsdlc:sdlc-harness:begin -->",
-        "<!-- sdlc-harness:begin -->",
-        "# pjsdlc:sdlc-harness:make:begin",
-        "# sdlc-harness:make:begin",
-        "# pjsdlc:sdlc-harness:github-workflow:begin",
-    ].some((marker) => content.includes(marker));
-}
-function rootConflictPath(currentCandidates, legacyCandidates) {
-    return [...currentCandidates, ...legacyCandidates]
-        .map((candidate) => `${candidate.source}=${candidate.harnessFolderName}`)
-        .join(", ");
-}
-function item(migrationId, status, pathLabel, message) {
-    return {
-        id: legacySdlcHarnessMigration.id,
-        introducedIn: legacySdlcHarnessMigration.introducedIn,
-        description: legacySdlcHarnessMigration.description,
-        scope: legacySdlcHarnessMigration.scope,
-        status,
-        path: pathLabel,
-        message,
-    };
-}
-function parseJsonRecord(content, pathLabel) {
-    const parsed = JSON.parse(content);
-    if (!isJsonRecord(parsed)) {
-        throw new Error(`${pathLabel} must contain a JSON object`);
-    }
-    return parsed;
-}
-function isJsonRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}

package/dist/lib/long-task-acceptance-reference.d.ts

@@ -1,22 +0,0 @@
-import type { CompiledDeliveryContractV2, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-export type AcceptanceReference = {
-    scope: "global";
-    check_key: string;
-    assertion_key: string;
-} | {
-    scope: "outcome";
-    outcome_key: string;
-    check_key: string;
-    assertion_key: string;
-};
-export interface ResolvedAcceptanceAssertion {
-    ref: string;
-    scope: AcceptanceReference["scope"];
-    outcome_key: string | null;
-    check_key: string;
-    assertion_key: string;
-    check: DeliveryCheckV2;
-    assertion: DeliveryAssertionV2;
-}
-export declare function parseAcceptanceReference(ref: string): AcceptanceReference;
-export declare function resolveAcceptanceAssertion(contract: DeliveryContractV2 | CompiledDeliveryContractV2, ref: string): ResolvedAcceptanceAssertion | null;

package/dist/lib/long-task-acceptance-reference.js

@@ -1,46 +0,0 @@
-export function parseAcceptanceReference(ref) {
-    const parts = ref.split(".");
-    if (parts.length !== 3 || parts.some((part) => !part))
-        throw new Error(`acceptance_reference_invalid:${ref}`);
-    const [owner, checkKey, assertionKey] = parts;
-    return owner === "GLOBAL"
-        ? {
-            scope: "global",
-            check_key: checkKey,
-            assertion_key: assertionKey,
-        }
-        : {
-            scope: "outcome",
-            outcome_key: owner,
-            check_key: checkKey,
-            assertion_key: assertionKey,
-        };
-}
-export function resolveAcceptanceAssertion(contract, ref) {
-    let reference;
-    try {
-        reference = parseAcceptanceReference(ref);
-    }
-    catch {
-        return null;
-    }
-    const contractLike = contract;
-    const checks = reference.scope === "global"
-        ? contractLike.global.acceptance.checks
-        : contractLike.outcomes.find((outcome) => outcome.key === reference.outcome_key)?.acceptance.checks;
-    const check = checks?.find((item) => item.key === reference.check_key);
-    const assertion = check
-        ? [...check.positive_assertions, ...check.negative_assertions].find((item) => item.key === reference.assertion_key)
-        : null;
-    if (!check || !assertion)
-        return null;
-    return {
-        ref,
-        scope: reference.scope,
-        outcome_key: reference.scope === "outcome" ? reference.outcome_key : null,
-        check_key: reference.check_key,
-        assertion_key: reference.assertion_key,
-        check,
-        assertion,
-    };
-}

package/dist/lib/long-task-acceptance-shape.d.ts

@@ -1,5 +0,0 @@
-import type { CounterfactualControlV2, EnvironmentRequirementV2, GlobalCounterfactualControlV2, PopulationRequirementV2 } from "./long-task-delivery-types.js";
-export declare function parseCounterfactuals(value: unknown, label: string): CounterfactualControlV2[];
-export declare function parseGlobalCounterfactuals(value: unknown, label: string): GlobalCounterfactualControlV2[];
-export declare function parsePopulation(value: unknown, label: string): PopulationRequirementV2;
-export declare function parseEnvironmentRequirements(value: unknown, label: string): EnvironmentRequirementV2[];

package/dist/lib/long-task-acceptance-shape.js

@@ -1,198 +0,0 @@
-import { parseKeyedStatements } from "./long-task-product-shape.js";
-import { array, fail, key, literal, object, repositoryFile, repositoryFiles, string, strings, } from "./long-task-shape-primitives.js";
-export function parseCounterfactuals(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "binding_key",
-            "claims",
-            "check_key",
-            "mutation",
-            "expected_assertion_failures",
-        ], ["preserved_assertions", "allowed_fanout_assertions"]);
-        const mutation = object(row.mutation, `${itemLabel}.mutation`, ["type"], [
-            "paths",
-            "path",
-            "fixture_path",
-            "pointer",
-            "value",
-            "match",
-            "replacement",
-        ]);
-        const type = literal(mutation.type, [
-            "remove_paths",
-            "replace_file",
-            "replace_json_value",
-            "replace_text",
-        ], `${itemLabel}.mutation.type`);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            binding_key: key(row.binding_key, `${itemLabel}.binding_key`),
-            claims: strings(row.claims, `${itemLabel}.claims`),
-            check_key: key(row.check_key, `${itemLabel}.check_key`),
-            mutation: parseCounterfactualMutation(row.mutation, `${itemLabel}.mutation`),
-            expected_assertion_failures: strings(row.expected_assertion_failures, `${itemLabel}.expected_assertion_failures`).map((item, assertionIndex) => key(item, `${itemLabel}.expected_assertion_failures[${assertionIndex}]`)),
-            preserved_assertions: Object.hasOwn(row, "preserved_assertions")
-                ? strings(row.preserved_assertions, `${itemLabel}.preserved_assertions`).map((item, assertionIndex) => key(item, `${itemLabel}.preserved_assertions[${assertionIndex}]`))
-                : [],
-            allowed_fanout_assertions: Object.hasOwn(row, "allowed_fanout_assertions")
-                ? strings(row.allowed_fanout_assertions, `${itemLabel}.allowed_fanout_assertions`).map((item, assertionIndex) => key(item, `${itemLabel}.allowed_fanout_assertions[${assertionIndex}]`))
-                : [],
-        };
-    });
-}
-export function parseGlobalCounterfactuals(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "binding_ref",
-            "claims",
-            "check_key",
-            "mutation",
-            "expected_assertion_failures",
-        ], ["preserved_assertions", "allowed_fanout_assertions"]);
-        const bindingRef = string(row.binding_ref, `${itemLabel}.binding_ref`);
-        if (!/^[a-z0-9][a-z0-9-]*\.[a-z0-9][a-z0-9-]*$/u.test(bindingRef))
-            fail(`${itemLabel}.binding_ref`, "must be <outcome-key>.<binding-key>");
-        const claims = strings(row.claims, `${itemLabel}.claims`);
-        if (!claims.length)
-            fail(`${itemLabel}.claims`, "must not be empty");
-        const failures = strings(row.expected_assertion_failures, `${itemLabel}.expected_assertion_failures`).map((entry, assertionIndex) => key(entry, `${itemLabel}.expected_assertion_failures[${assertionIndex}]`));
-        if (!failures.length)
-            fail(`${itemLabel}.expected_assertion_failures`, "must not be empty");
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            binding_ref: bindingRef,
-            claims,
-            check_key: key(row.check_key, `${itemLabel}.check_key`),
-            mutation: parseCounterfactualMutation(row.mutation, `${itemLabel}.mutation`),
-            expected_assertion_failures: failures,
-            preserved_assertions: Object.hasOwn(row, "preserved_assertions")
-                ? strings(row.preserved_assertions, `${itemLabel}.preserved_assertions`).map((entry, assertionIndex) => key(entry, `${itemLabel}.preserved_assertions[${assertionIndex}]`))
-                : [],
-            allowed_fanout_assertions: Object.hasOwn(row, "allowed_fanout_assertions")
-                ? strings(row.allowed_fanout_assertions, `${itemLabel}.allowed_fanout_assertions`).map((entry, assertionIndex) => key(entry, `${itemLabel}.allowed_fanout_assertions[${assertionIndex}]`))
-                : [],
-        };
-    });
-}
-function parseCounterfactualMutation(value, label) {
-    const mutation = object(value, label, ["type"], [
-        "paths",
-        "path",
-        "fixture_path",
-        "pointer",
-        "value",
-        "match",
-        "replacement",
-    ]);
-    const type = literal(mutation.type, [
-        "remove_paths",
-        "replace_file",
-        "replace_json_value",
-        "replace_text",
-    ], `${label}.type`);
-    if (type === "remove_paths")
-        return {
-            type,
-            paths: repositoryFiles(mutation.paths, `${label}.paths`),
-        };
-    const target = repositoryFile(mutation.path, `${label}.path`);
-    if (type === "replace_file")
-        return {
-            type,
-            path: target,
-            fixture_path: repositoryFile(mutation.fixture_path, `${label}.fixture_path`),
-        };
-    if (type === "replace_json_value") {
-        const pointer = string(mutation.pointer, `${label}.pointer`);
-        if (!/^\/(?:[^~/]|~[01])+(?:\/(?:[^~/]|~[01])+)*$/u.test(pointer))
-            fail(`${label}.pointer`, "must be a non-root RFC 6901 JSON pointer");
-        if (!Object.hasOwn(mutation, "value"))
-            fail(`${label}.value`, "must be present");
-        assertJsonValue(mutation.value, `${label}.value`);
-        return { type, path: target, pointer, value: mutation.value };
-    }
-    const match = string(mutation.match, `${label}.match`);
-    const replacement = typeof mutation.replacement === "string"
-        ? mutation.replacement
-        : fail(`${label}.replacement`, "must be a string");
-    if (match === replacement)
-        fail(`${label}.replacement`, "must differ from match");
-    return { type, path: target, match, replacement };
-}
-function assertJsonValue(value, label) {
-    if (value === undefined ||
-        typeof value === "function" ||
-        typeof value === "symbol" ||
-        typeof value === "bigint")
-        fail(label, "must be JSON-compatible");
-    try {
-        const encoded = JSON.stringify(value);
-        if (encoded === undefined)
-            fail(label, "must be JSON-compatible");
-        JSON.parse(encoded);
-    }
-    catch {
-        fail(label, "must be JSON-compatible");
-    }
-}
-export function parsePopulation(value, label) {
-    const row = object(value, label, [
-        "check_key",
-        "universe_binding_key",
-        "claims",
-        "observations",
-        "exclusion_rules",
-    ]);
-    const observations = object(row.observations, `${label}.observations`, [
-        "universe_ids",
-        "eligible_ids",
-        "observed_ids",
-        "excluded_items",
-    ]);
-    return {
-        check_key: key(row.check_key, `${label}.check_key`),
-        universe_binding_key: key(row.universe_binding_key, `${label}.universe_binding_key`),
-        claims: strings(row.claims, `${label}.claims`),
-        observations: {
-            universe_ids: string(observations.universe_ids, `${label}.observations.universe_ids`),
-            eligible_ids: string(observations.eligible_ids, `${label}.observations.eligible_ids`),
-            observed_ids: string(observations.observed_ids, `${label}.observations.observed_ids`),
-            excluded_items: string(observations.excluded_items, `${label}.observations.excluded_items`),
-        },
-        exclusion_rules: parseKeyedStatements(row.exclusion_rules, `${label}.exclusion_rules`),
-    };
-}
-export function parseEnvironmentRequirements(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const base = object(item, itemLabel, ["key", "kind"], ["target", "host", "port", "timeout_ms"]);
-        const kindValue = literal(base.kind, ["executable", "file", "directory", "env_var", "loopback_tcp"], `${itemLabel}.kind`);
-        const requirementKey = key(base.key, `${itemLabel}.key`);
-        if (kindValue !== "loopback_tcp")
-            return {
-                key: requirementKey,
-                kind: kindValue,
-                target: kindValue === "file" || kindValue === "directory"
-                    ? repositoryFile(base.target, `${itemLabel}.target`)
-                    : string(base.target, `${itemLabel}.target`),
-            };
-        const host = literal(base.host, ["127.0.0.1", "::1", "localhost"], `${itemLabel}.host`);
-        const port = Number(base.port);
-        const timeout = Number(base.timeout_ms);
-        if (!Number.isInteger(port) || port < 1 || port > 65535)
-            fail(`${itemLabel}.port`, "must be an integer from 1 to 65535");
-        if (!Number.isInteger(timeout) || timeout < 10 || timeout > 60_000)
-            fail(`${itemLabel}.timeout_ms`, "must be an integer from 10 to 60000");
-        return {
-            key: requirementKey,
-            kind: kindValue,
-            host,
-            port,
-            timeout_ms: timeout,
-        };
-    });
-}

package/dist/lib/long-task-activation-validation.d.ts

@@ -1,21 +0,0 @@
-import type { AuthoringPreflightDiagnosticV1 } from "./long-task-authoring-preflight-types.js";
-import { type CompiledClaimsV2 } from "./long-task-claims.js";
-import type { CompiledCheckV2, CompiledOutcomeV2, CompiledSourceItemV2, ContextAuthoritySnapshotV2, DeliveryContractV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-import { type RiskDecisionV2 } from "./long-task-risk.js";
-export interface ActivationValidationResult {
-    claims: CompiledClaimsV2 | null;
-    risk: RiskDecisionV2 | null;
-    source_hashes: Record<string, string> | null;
-    source_items: CompiledSourceItemV2[] | null;
-    context_snapshot: ContextAuthoritySnapshotV2 | null;
-    workspace: WorkspaceManifestV2 | null;
-    global_checks: CompiledCheckV2[];
-    outcomes: CompiledOutcomeV2[];
-}
-export declare function validateContractForActivation(options: {
-    contract: DeliveryContractV2;
-    repository: string;
-    workdir: string;
-    mode: "collect" | "fail_fast";
-    diagnostics?: AuthoringPreflightDiagnosticV1[];
-}): Promise<ActivationValidationResult>;