project-tiny-context-harness 0.8.7 → 0.8.10

package/dist/lib/long-task-source-item-parser.js

@@ -1,21 +1,28 @@
-import { parseDesignResourceHandoffShape } from "./design-resource-handoff-shape.js";
+import { parseDesignResourceHandoffInputShape } from "./design-resource-handoff-shape.js";
 import { parseSemanticFactManifestShape } from "./semantic-fact-manifest-shape.js";
-import { normalizeSourceItemText, parseSourceBackgroundMarker, parseSourceItemStartMarker, SOURCE_BACKGROUND_END, SOURCE_BACKGROUND_START, SOURCE_ITEM_END, SOURCE_ITEM_START, validateSourceBackgroundLine, } from "./long-task-source-markers.js";
-import { parseStrictYaml, sha256Hex } from "./strict-codec.js";
+import { assertNoOpenOwnedSection, assertOwnedSourceSectionsClosed, consumeBackgroundBoundary, consumeOwnedText, consumeSourceItemBoundary, } from "./long-task-source-owned-sections.js";
+import { formalBlockBody, forEachSourceLine } from "./source-line-scanner.js";
+import { parseStrictYaml } from "./strict-codec.js";
 const DESIGN_RESOURCE_START = /^\s*```yaml[ \t]+design-resource-handoff-v1[ \t]*$/u;
 const SEMANTIC_FACT_START = /^\s*```yaml[ \t]+semantic-fact-manifest-v1[ \t]*$/u;
 const FORMAL_BLOCK_END = /^\s*```[ \t]*$/u;
 export function parseSourceItems(sourcePath, content) {
-    const state = sourceParseState(sourcePath);
-    const lines = content.replace(/\r\n?/gu, "\n").split("\n");
-    for (const [index, line] of lines.entries())
-        consumeSourceLine(state, line, index + 1);
+    return parseSourceDocument(sourcePath, content).items;
+}
+export function parseSourceDocument(sourcePath, content) {
+    const state = sourceParseState(sourcePath, content);
+    forEachSourceLine(content, (line, startOffset, _endOffset, nextOffset, lineNumber) => consumeSourceLine(state, line, lineNumber, startOffset, nextOffset));
     assertSourceSectionsClosed(state);
-    return state.items;
+    return {
+        items: state.items,
+        designResourceHandoff: state.designResourceHandoff,
+        semanticFactManifest: state.semanticFactManifest,
+    };
 }
-function sourceParseState(sourcePath) {
+function sourceParseState(sourcePath, content) {
     return {
         sourcePath,
+        content,
         items: [],
         seen: new Set(),
         seenBackground: new Set(),
@@ -24,12 +31,14 @@ function sourceParseState(sourcePath) {
         formalBlock: null,
         designResourceBlocks: 0,
         semanticFactBlocks: 0,
+        designResourceHandoff: null,
+        semanticFactManifest: null,
     };
 }
-function consumeSourceLine(state, line, lineNumber) {
-    if (consumeOpenFormalBlock(state, line))
+function consumeSourceLine(state, line, lineNumber, startOffset, nextOffset) {
+    if (consumeOpenFormalBlock(state, line, startOffset))
         return;
-    if (startFormalBlock(state, line, lineNumber))
+    if (startFormalBlock(state, line, lineNumber, nextOffset))
         return;
     if (consumeSourceItemBoundary(state, line, lineNumber))
         return;
@@ -37,19 +46,17 @@ function consumeSourceLine(state, line, lineNumber) {
         return;
     consumeOwnedText(state, line, lineNumber);
 }
-function consumeOpenFormalBlock(state, line) {
+function consumeOpenFormalBlock(state, line, startOffset) {
     if (!state.formalBlock)
         return false;
-    if (!FORMAL_BLOCK_END.test(line)) {
-        state.formalBlock.lines.push(line);
+    if (!FORMAL_BLOCK_END.test(line))
         return true;
-    }
     try {
-        const value = parseStrictYaml(state.formalBlock.lines.join("\n"));
+        const value = parseStrictYaml(formalBlockBody(state.content, state.formalBlock.bodyStartOffset, startOffset, state.formalBlock.owner === "design-resource-handoff-v1"));
         if (state.formalBlock.owner === "design-resource-handoff-v1")
-            parseDesignResourceHandoffShape(value);
+            state.designResourceHandoff = parseDesignResourceHandoffInputShape(value);
         else
-            parseSemanticFactManifestShape(value);
+            state.semanticFactManifest = parseSemanticFactManifestShape(value);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -58,7 +65,7 @@ function consumeOpenFormalBlock(state, line) {
     state.formalBlock = null;
     return true;
 }
-function startFormalBlock(state, line, lineNumber) {
+function startFormalBlock(state, line, lineNumber, nextOffset) {
     const owner = DESIGN_RESOURCE_START.test(line)
         ? "design-resource-handoff-v1"
         : SEMANTIC_FACT_START.test(line)
@@ -79,98 +86,13 @@ function startFormalBlock(state, line, lineNumber) {
     }
     state.formalBlock = {
         owner,
-        lines: [],
+        bodyStartOffset: nextOffset,
         line: lineNumber,
     };
     return true;
 }
-function consumeSourceItemBoundary(state, line, lineNumber) {
-    const start = SOURCE_ITEM_START.exec(line);
-    if (start) {
-        assertNoOpenOwnedSection(state, lineNumber);
-        state.open = {
-            ...parseSourceItemStartMarker(state.sourcePath, lineNumber, start[1]),
-            lines: [],
-            line: lineNumber,
-        };
-        return true;
-    }
-    if (!SOURCE_ITEM_END.test(line))
-        return false;
-    if (!state.open)
-        throw new Error(`source_item_end_without_start:${state.sourcePath}:${lineNumber}`);
-    closeSourceItem(state);
-    return true;
-}
-function closeSourceItem(state) {
-    const open = state.open;
-    const normalizedText = normalizeSourceItemText(open.lines.join("\n"));
-    if (!normalizedText)
-        throw new Error(`source_item_empty:${state.sourcePath}:${open.key}`);
-    if (state.seen.has(open.key))
-        throw new Error(`source_item_key_duplicate:${open.key}`);
-    state.seen.add(open.key);
-    state.items.push({
-        key: open.key,
-        kind: open.kind,
-        ...(open.aspect ? { aspect: open.aspect } : {}),
-        source_path: state.sourcePath,
-        normalized_text: normalizedText,
-        text_sha256: sha256Hex(normalizedText),
-        ...(open.risk_semantics ? { risk_semantics: open.risk_semantics } : {}),
-    });
-    state.open = null;
-}
-function consumeBackgroundBoundary(state, line, lineNumber) {
-    const start = SOURCE_BACKGROUND_START.exec(line);
-    if (start) {
-        assertNoOpenOwnedSection(state, lineNumber);
-        const declaration = parseSourceBackgroundMarker(state.sourcePath, lineNumber, start[1]);
-        if (state.seenBackground.has(declaration.key))
-            throw new Error(`source_background_key_duplicate:${declaration.key}`);
-        state.seenBackground.add(declaration.key);
-        state.background = {
-            ...declaration,
-            substantiveLines: 0,
-            line: lineNumber,
-        };
-        return true;
-    }
-    if (!SOURCE_BACKGROUND_END.test(line))
-        return false;
-    if (!state.background)
-        throw new Error(`source_background_end_without_start:${state.sourcePath}:${lineNumber}`);
-    if (!state.background.substantiveLines)
-        throw new Error(`source_background_empty:${state.sourcePath}:${state.background.key}`);
-    state.background = null;
-    return true;
-}
-function assertNoOpenOwnedSection(state, lineNumber) {
-    if (!state.open && !state.background)
-        return;
-    throw new Error(`source_section_nested_or_overlapping:${state.sourcePath}:${state.open?.key ?? state.background?.key}:${lineNumber}`);
-}
-function consumeOwnedText(state, line, lineNumber) {
-    if (line.includes("ty-source-item:start") ||
-        line.includes("ty-source-item:end") ||
-        line.includes("ty-source-background:start") ||
-        line.includes("ty-source-background:end"))
-        throw new Error(`source_item_marker_invalid:${state.sourcePath}:${lineNumber}`);
-    if (state.open)
-        state.open.lines.push(line);
-    else if (state.background) {
-        validateSourceBackgroundLine(state.sourcePath, state.background.key, state.background.reason, lineNumber, line);
-        if (line.trim())
-            state.background.substantiveLines += 1;
-    }
-    else if (line.trim())
-        throw new Error(`source_text_unclassified:${state.sourcePath}:${lineNumber}`);
-}
 function assertSourceSectionsClosed(state) {
-    if (state.open)
-        throw new Error(`source_item_unclosed:${state.sourcePath}:${state.open.key}:${state.open.line}`);
-    if (state.background)
-        throw new Error(`source_background_unclosed:${state.sourcePath}:${state.background.key}:${state.background.line}`);
+    assertOwnedSourceSectionsClosed(state);
     if (state.formalBlock)
         throw new Error(`source_formal_block_unclosed:${state.sourcePath}:${state.formalBlock.owner}:${state.formalBlock.line}`);
 }

package/dist/lib/long-task-source-owned-sections.d.ts

@@ -0,0 +1,29 @@
+import type { CompiledSourceItemV2, SourceItemKind } from "./long-task-delivery-types.js";
+interface OpenSourceItem {
+    key: string;
+    kind: SourceItemKind;
+    aspect?: CompiledSourceItemV2["aspect"];
+    risk_semantics?: CompiledSourceItemV2["risk_semantics"];
+    lines: string[];
+    line: number;
+}
+interface OpenSourceBackground {
+    key: string;
+    reason: string;
+    substantiveLines: number;
+    line: number;
+}
+export interface OwnedSourceParseState {
+    sourcePath: string;
+    items: CompiledSourceItemV2[];
+    seen: Set<string>;
+    seenBackground: Set<string>;
+    open: OpenSourceItem | null;
+    background: OpenSourceBackground | null;
+}
+export declare function consumeSourceItemBoundary(state: OwnedSourceParseState, line: string, lineNumber: number): boolean;
+export declare function consumeBackgroundBoundary(state: OwnedSourceParseState, line: string, lineNumber: number): boolean;
+export declare function assertNoOpenOwnedSection(state: OwnedSourceParseState, lineNumber: number): void;
+export declare function consumeOwnedText(state: OwnedSourceParseState, line: string, lineNumber: number): void;
+export declare function assertOwnedSourceSectionsClosed(state: OwnedSourceParseState): void;
+export {};

package/dist/lib/long-task-source-owned-sections.js

@@ -0,0 +1,90 @@
+import { normalizeSourceItemText, parseSourceBackgroundMarker, parseSourceItemStartMarker, SOURCE_BACKGROUND_END, SOURCE_BACKGROUND_START, SOURCE_ITEM_END, SOURCE_ITEM_START, validateSourceBackgroundLine, } from "./long-task-source-markers.js";
+import { sha256Hex } from "./strict-codec.js";
+export function consumeSourceItemBoundary(state, line, lineNumber) {
+    const start = SOURCE_ITEM_START.exec(line);
+    if (start) {
+        assertNoOpenOwnedSection(state, lineNumber);
+        state.open = {
+            ...parseSourceItemStartMarker(state.sourcePath, lineNumber, start[1]),
+            lines: [],
+            line: lineNumber,
+        };
+        return true;
+    }
+    if (!SOURCE_ITEM_END.test(line))
+        return false;
+    if (!state.open)
+        throw new Error(`source_item_end_without_start:${state.sourcePath}:${lineNumber}`);
+    closeSourceItem(state);
+    return true;
+}
+function closeSourceItem(state) {
+    const open = state.open;
+    const normalizedText = normalizeSourceItemText(open.lines.join("\n"));
+    if (!normalizedText)
+        throw new Error(`source_item_empty:${state.sourcePath}:${open.key}`);
+    if (state.seen.has(open.key))
+        throw new Error(`source_item_key_duplicate:${open.key}`);
+    state.seen.add(open.key);
+    state.items.push({
+        key: open.key,
+        kind: open.kind,
+        ...(open.aspect ? { aspect: open.aspect } : {}),
+        source_path: state.sourcePath,
+        normalized_text: normalizedText,
+        text_sha256: sha256Hex(normalizedText),
+        ...(open.risk_semantics ? { risk_semantics: open.risk_semantics } : {}),
+    });
+    state.open = null;
+}
+export function consumeBackgroundBoundary(state, line, lineNumber) {
+    const start = SOURCE_BACKGROUND_START.exec(line);
+    if (start) {
+        assertNoOpenOwnedSection(state, lineNumber);
+        const declaration = parseSourceBackgroundMarker(state.sourcePath, lineNumber, start[1]);
+        if (state.seenBackground.has(declaration.key))
+            throw new Error(`source_background_key_duplicate:${declaration.key}`);
+        state.seenBackground.add(declaration.key);
+        state.background = {
+            ...declaration,
+            substantiveLines: 0,
+            line: lineNumber,
+        };
+        return true;
+    }
+    if (!SOURCE_BACKGROUND_END.test(line))
+        return false;
+    if (!state.background)
+        throw new Error(`source_background_end_without_start:${state.sourcePath}:${lineNumber}`);
+    if (!state.background.substantiveLines)
+        throw new Error(`source_background_empty:${state.sourcePath}:${state.background.key}`);
+    state.background = null;
+    return true;
+}
+export function assertNoOpenOwnedSection(state, lineNumber) {
+    if (!state.open && !state.background)
+        return;
+    throw new Error(`source_section_nested_or_overlapping:${state.sourcePath}:${state.open?.key ?? state.background?.key}:${lineNumber}`);
+}
+export function consumeOwnedText(state, line, lineNumber) {
+    if (line.includes("ty-source-item:start") ||
+        line.includes("ty-source-item:end") ||
+        line.includes("ty-source-background:start") ||
+        line.includes("ty-source-background:end"))
+        throw new Error(`source_item_marker_invalid:${state.sourcePath}:${lineNumber}`);
+    if (state.open)
+        state.open.lines.push(line);
+    else if (state.background) {
+        validateSourceBackgroundLine(state.sourcePath, state.background.key, state.background.reason, lineNumber, line);
+        if (line.trim())
+            state.background.substantiveLines += 1;
+    }
+    else if (line.trim())
+        throw new Error(`source_text_unclassified:${state.sourcePath}:${lineNumber}`);
+}
+export function assertOwnedSourceSectionsClosed(state) {
+    if (state.open)
+        throw new Error(`source_item_unclosed:${state.sourcePath}:${state.open.key}:${state.open.line}`);
+    if (state.background)
+        throw new Error(`source_background_unclosed:${state.sourcePath}:${state.background.key}:${state.background.line}`);
+}

package/dist/lib/migrations.js

@@ -9,6 +9,7 @@ import { createDesignMdIfMissing, DESIGN_MD_PATH } from "./design-md.js";
 import { ensureDir, listFiles, pathExists, readText, writeTextIfChanged, } from "./fs.js";
 import { harnessConfigPath, harnessRoot } from "./harness-root.js";
 import { legacySdlcHarnessMigration } from "./legacy-sdlc-migration.js";
+import { modularityCapabilityWaiverMigration } from "./modularity-capability-migration.js";
 import { parseYaml, stringifyYaml } from "./yaml.js";
 import { semanticDriftMigrationFields } from "./long-task-semantic-drift-migration.js";
 async function verifyNoop() {
@@ -18,6 +19,7 @@ const REMOVED_NORMAL_LONG_TASK_SKILL = "normal-long-task";
 const REMOVED_NORMAL_LONG_TASK_SKILL_SHA256 = "7a4f755da9a32e07f258d6c7fc5e5c70395257c72efb8a9ad4995cddcc4c73ba";
 export const migrations = [
     legacySdlcHarnessMigration,
+    modularityCapabilityWaiverMigration,
     {
         id: "long-task-v2-semantic-drift-authority",
         introducedIn: "0.7.2",

package/dist/lib/modularity-capability-migration.d.ts

@@ -0,0 +1,2 @@
+import type { Migration } from "./migrations.js";
+export declare const modularityCapabilityWaiverMigration: Migration;

package/dist/lib/modularity-capability-migration.js

@@ -0,0 +1,165 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { harnessConfigPath } from "./harness-root.js";
+import { DEFAULT_MODULARITY_LINE_LIMIT, hasLegacyHeuristicOnlyWaiverRisk, isLifecycleCompleteModularityWaiverConfig, isLikelyGeneratedSourceContent, } from "./modularity.js";
+import { toPosix } from "./source-files.js";
+import { parseYaml, stringifyYaml } from "./yaml.js";
+const MIGRATION_ID = "modularity-capability-waiver-cleanup";
+const INTRODUCED_IN = "0.8.8";
+const DESCRIPTION = "Remove scoped modularity waivers that existed only for unsupported cross-language heuristic metrics.";
+const SCOPE = "<harnessRoot>/config.yaml modularity.waivers";
+export const modularityCapabilityWaiverMigration = {
+    id: MIGRATION_ID,
+    introducedIn: INTRODUCED_IN,
+    description: DESCRIPTION,
+    scope: SCOPE,
+    risk: "safe",
+    manualMessage: "Remove only the waiver identified as legacy-heuristic-only; retain any waiver that still covers physical-line or supported language metrics.",
+    detect: detectModularityCapabilityWaivers,
+    apply: migrateModularityCapabilityWaivers,
+    verify: verifyModularityCapabilityWaivers,
+};
+async function detectModularityCapabilityWaivers(projectRoot) {
+    const config = await readRawConfig(projectRoot);
+    if (!config) {
+        return [];
+    }
+    const candidates = await obsoleteWaiverIndexes(projectRoot, config.value);
+    return candidates.map(({ index, relativePath }) => ({
+        id: MIGRATION_ID,
+        introducedIn: INTRODUCED_IN,
+        description: DESCRIPTION,
+        scope: SCOPE,
+        status: "safe_pending",
+        path: `${config.relativePath}#modularity.waivers[${index}]`,
+        message: `${relativePath} exceeded only metrics from the retired cross-language JS heuristic; upgrade can remove this now-inapplicable waiver without changing supported line-risk coverage.`,
+    }));
+}
+async function migrateModularityCapabilityWaivers(projectRoot, _root, report) {
+    const config = await readRawConfig(projectRoot);
+    if (!config) {
+        report.skipped.push(MIGRATION_ID);
+        return;
+    }
+    const candidates = await obsoleteWaiverIndexes(projectRoot, config.value);
+    if (candidates.length === 0) {
+        report.skipped.push(MIGRATION_ID);
+        return;
+    }
+    const modularity = row(config.value.modularity);
+    const waivers = Array.isArray(modularity?.waivers) ? modularity.waivers : [];
+    const removed = new Set(candidates.map((candidate) => candidate.index));
+    const retained = waivers.filter((_waiver, index) => !removed.has(index));
+    if (retained.length > 0) {
+        modularity.waivers = retained;
+    }
+    else {
+        delete modularity.waivers;
+    }
+    if (await writeTextIfChanged(config.absolutePath, stringifyYaml(config.value))) {
+        report.changed.push(`${config.relativePath}#modularity.waivers removed=${removed.size}`);
+    }
+    else {
+        report.skipped.push(MIGRATION_ID);
+    }
+}
+async function verifyModularityCapabilityWaivers(projectRoot) {
+    const remaining = await detectModularityCapabilityWaivers(projectRoot);
+    if (remaining.length > 0) {
+        throw new Error("modularity capability waiver cleanup migration verification failed");
+    }
+}
+async function obsoleteWaiverIndexes(projectRoot, config) {
+    const modularity = row(config.modularity);
+    if (!modularity ||
+        (modularity.policy ?? "scoped_waivers") !== "scoped_waivers") {
+        return [];
+    }
+    if (modularity.limit !== undefined &&
+        (typeof modularity.limit !== "number" ||
+            !Number.isInteger(modularity.limit) ||
+            modularity.limit <= 0)) {
+        return [];
+    }
+    const lineLimit = typeof modularity.limit === "number"
+        ? modularity.limit
+        : DEFAULT_MODULARITY_LINE_LIMIT;
+    if (!Array.isArray(modularity.waivers)) {
+        return [];
+    }
+    const targets = modularity.waivers.map((value) => {
+        const waiver = row(value);
+        return safeProjectTarget(projectRoot, waiver?.path);
+    });
+    const targetCounts = new Map();
+    for (const target of targets) {
+        if (target) {
+            const identity = targetIdentity(target.relativePath);
+            targetCounts.set(identity, (targetCounts.get(identity) ?? 0) + 1);
+        }
+    }
+    const candidates = [];
+    for (const [index, value] of modularity.waivers.entries()) {
+        if (!isLifecycleCompleteModularityWaiverConfig(value)) {
+            continue;
+        }
+        const target = targets[index];
+        if (!target ||
+            targetCounts.get(targetIdentity(target.relativePath)) !== 1) {
+            continue;
+        }
+        let content;
+        try {
+            const stat = await fs.stat(target.absolutePath);
+            if (!stat.isFile()) {
+                continue;
+            }
+            content = await fs.readFile(target.absolutePath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (isLikelyGeneratedSourceContent(content)) {
+            continue;
+        }
+        if (hasLegacyHeuristicOnlyWaiverRisk(content, target.relativePath, lineLimit)) {
+            candidates.push({ index, relativePath: target.relativePath });
+        }
+    }
+    return candidates;
+}
+async function readRawConfig(projectRoot) {
+    const relativePath = await harnessConfigPath(projectRoot);
+    const absolutePath = path.join(projectRoot, relativePath);
+    if (!(await pathExists(absolutePath))) {
+        return undefined;
+    }
+    const value = row(parseYaml(await readText(absolutePath)));
+    return value
+        ? { absolutePath, relativePath: toPosix(relativePath), value }
+        : undefined;
+}
+function safeProjectTarget(projectRoot, value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return undefined;
+    }
+    const absolutePath = path.resolve(projectRoot, value);
+    const relativePath = toPosix(path.relative(projectRoot, absolutePath));
+    if (relativePath === ".." ||
+        relativePath.startsWith("../") ||
+        path.isAbsolute(relativePath)) {
+        return undefined;
+    }
+    return { absolutePath, relativePath };
+}
+function row(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function targetIdentity(relativePath) {
+    return process.platform === "win32"
+        ? relativePath.toLowerCase()
+        : relativePath;
+}

package/dist/lib/modularity-python.d.ts

@@ -0,0 +1,7 @@
+export interface PythonFunctionMetric {
+    symbol: string;
+    line: number;
+    statements: number;
+    branches: number;
+}
+export declare function analyzePythonFunctions(content: string): PythonFunctionMetric[];