project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/context-manifest-schema.js

@@ -1,21 +1,5 @@
 import { parse } from "smol-toml";
-const TOP_LEVEL_FIELDS = new Set(["areas", "context"]);
-const AREA_FIELDS = new Set([
-    "id",
-    "root",
-    "context",
-    "kind",
-    "default",
-    "forbidden_runtime_dependencies",
-]);
-const CONTEXT_FIELDS = new Set([
-    "path",
-    "role",
-    "read_when",
-    "read_policy",
-    "triggers",
-    "default_children",
-]);
+import { CONTEXT_AREA_FIELDS, CONTEXT_NODE_FIELDS, CONTEXT_TOP_LEVEL_FIELDS, } from "./context-catalog/catalog-portable-contract.js";
 export function parseContextManifest(content, file = "project_context/context.toml") {
     const errors = [];
     let parsed;
@@ -29,7 +13,7 @@ export function parseContextManifest(content, file = "project_context/context.to
             ],
         };
     }
-    rejectUnknownFields(parsed, TOP_LEVEL_FIELDS, file, errors);
+    rejectUnknownFields(parsed, CONTEXT_TOP_LEVEL_FIELDS, file, errors);
     const rawAreas = tableArray(parsed.areas, "[[areas]]", file, errors);
     const rawContexts = tableArray(parsed.context, "[[context]]", file, errors);
     const areaLines = tableLines(content, "areas");
@@ -37,7 +21,7 @@ export function parseContextManifest(content, file = "project_context/context.to
     const areas = [];
     for (const [index, value] of rawAreas.entries()) {
         const location = `${file} line ${areaLines[index] ?? 1}`;
-        rejectUnknownFields(value, AREA_FIELDS, location, errors);
+        rejectUnknownFields(value, CONTEXT_AREA_FIELDS, location, errors);
         const id = requiredString(value, "id", location, errors);
         const root = requiredString(value, "root", location, errors);
         const context = requiredString(value, "context", location, errors);
@@ -59,7 +43,7 @@ export function parseContextManifest(content, file = "project_context/context.to
     const contexts = [];
     for (const [index, value] of rawContexts.entries()) {
         const location = `${file} line ${contextLines[index] ?? 1}`;
-        rejectUnknownFields(value, CONTEXT_FIELDS, location, errors);
+        rejectUnknownFields(value, CONTEXT_NODE_FIELDS, location, errors);
         const path = requiredString(value, "path", location, errors);
         const role = requiredString(value, "role", location, errors);
         const readWhen = optionalString(value, "read_when", location, errors);
@@ -78,7 +62,8 @@ export function parseContextManifest(content, file = "project_context/context.to
             });
         }
     }
-    return { manifest: { areas, contexts }, errors };
+    const default_files = optionalStringArray(parsed, "default_files", file, errors);
+    return { manifest: { areas, contexts, default_files }, errors };
 }
 function tableArray(value, label, file, errors) {
     if (value === undefined) {

package/dist/lib/context-manifest.js

@@ -2,47 +2,7 @@ import path from "node:path";
 import { listFiles } from "./fs.js";
 export const CONTEXT_MANIFEST_PATH = "project_context/context.toml";
 export function defaultContextManifestTemplate() {
-    return [
-        "# Schema v4 Minimal Context graph manifest.",
-        "# Keep the default product/domain area for ordinary projects. Role context nodes",
-        "# are read-purpose slices owned by an area or, only when cross-domain, by the project root.",
-        "# A monorepo may place only Context-bearing implementation workspaces under",
-        "# project_context/workspaces/<workspace-id>/**. Each represented Context workspace",
-        "# maps one code root through existing area root/context fields and may contain several Areas.",
-        "# Keep cross-workspace Areas under project_context/areas/**; do not create empty",
-        "# Context directories for code workspaces with no durable facts.",
-        "# Prefer a small top-level repository-common default Area; keep workspace-local",
-        "# Context on-demand unless its facts are genuinely near-universal.",
-        "# Default/on-demand selection defines the starting read set, not a maximum;",
-        "# widen to any relevant area/shared Context when task dependencies require it.",
-        "# This optional sparse mirror adds no workspace schema or read/edit ACL. Use",
-        "# project-owned scope checks for task-local intended/supporting changed paths.",
-        "# When migrating deep files under project_context/areas/**, refine obvious",
-        "# contract/foundation/subdomain/verification/deployment/implementation-index/",
-        "# decision-rationale/archive files into [[context]] entries instead of keeping",
-        "# every Markdown file as an [[areas]] product owner.",
-        "",
-        "[[areas]]",
-        'id = "main"',
-        'root = "."',
-        'context = "project_context/areas/main.md"',
-        'kind = "app"',
-        "default = true",
-        "",
-        "[[context]]",
-        'path = "project_context/areas/main/verification.md"',
-        'role = "verification"',
-        'read_policy = "default"',
-        'triggers = ["test", "verify", "verification", "smoke", "ci"]',
-        "",
-        "# Example optional node:",
-        "# [[context]]",
-        '# path = "project_context/areas/main/deployment.md"',
-        '# role = "deployment"',
-        '# read_policy = "on-demand"',
-        '# triggers = ["deploy", "deployment", "runtime", "cloud", "docker"]',
-        "",
-    ].join("\n");
+    return '# Tiny Context routing. global.md is always read.\n# Add optional [[areas]] or [[context]] nodes only when useful.\n# read_policy = "default" traverses default_children; default_files selects files only.\n';
 }
 export async function contextManifestFromExistingAreas(projectRoot) {
     const areasRoot = path.join(projectRoot, "project_context", "areas");

package/dist/lib/context-markdown/context-markdown-analysis.d.ts

@@ -0,0 +1,15 @@
+import type { CatalogFile } from "../context-catalog/catalog-types.js";
+import type { ContextMarkdownCatalogAnalysis, ContextMarkdownFileAnalysis } from "./context-markdown-types.js";
+export declare function analyzeContextMarkdownCatalog(input: {
+    project_root: string;
+    files: CatalogFile[];
+    long_line_threshold: number;
+    file_overrides?: ReadonlyMap<string, Uint8Array | null>;
+}): Promise<ContextMarkdownCatalogAnalysis>;
+export declare function analyzeContextMarkdownFile(input: {
+    project_root: string;
+    file: CatalogFile;
+    catalog_files?: ReadonlyMap<string, CatalogFile>;
+    long_line_threshold: number;
+    file_overrides?: ReadonlyMap<string, Uint8Array | null>;
+}): Promise<ContextMarkdownFileAnalysis>;

package/dist/lib/context-markdown/context-markdown-analysis.js

@@ -0,0 +1,253 @@
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { compareUtf8Paths, isPathWithin, normalizeContextPath, } from "../context-catalog/catalog-paths.js";
+import { extractContextMarkdown } from "./context-markdown-extract.js";
+import { contextControllingSourceConflicts, resolveContextControllingSourceDeclaration, } from "../context-controlling-source.js";
+export async function analyzeContextMarkdownCatalog(input) {
+    const files = [];
+    const catalogFiles = new Map(input.files.map((file) => [file.path, file]));
+    for (const file of [...input.files].sort((left, right) => compareUtf8Paths(left.path, right.path)))
+        files.push(await analyzeContextMarkdownFile({
+            project_root: input.project_root,
+            file,
+            catalog_files: catalogFiles,
+            long_line_threshold: input.long_line_threshold,
+            file_overrides: input.file_overrides,
+        }));
+    const declarations = files.flatMap((file) => file.declarations);
+    const controllingSources = files.flatMap((file) => file.controlling_sources);
+    return {
+        files,
+        references: files.flatMap((file) => file.references),
+        controlling_sources: controllingSources,
+        controlling_source_conflicts: contextControllingSourceConflicts(controllingSources),
+        declarations,
+        invalid_declarations: files.flatMap((file) => file.invalid_declarations),
+        declaration_conflicts: declarationConflicts(declarations),
+    };
+}
+export async function analyzeContextMarkdownFile(input) {
+    const override = input.file_overrides?.get(input.file.path);
+    const content = override === undefined
+        ? await readFile(input.file.absolute_path, "utf8")
+        : Buffer.from(override ?? []).toString("utf8");
+    const extracted = extractContextMarkdown(content, input.file.path);
+    const lengths = lineLengths(content, input.long_line_threshold);
+    const references = [];
+    for (const reference of extracted.references) {
+        const resolved = await resolveReference(input.project_root, input.file, reference, input.catalog_files ?? new Map([[input.file.path, input.file]]), input.file_overrides);
+        if (resolved)
+            references.push(resolved);
+    }
+    const controllingSources = [];
+    for (const declaration of extracted.controlling_sources)
+        controllingSources.push(await resolveContextControllingSourceDeclaration(input.project_root, declaration));
+    return {
+        path: input.file.path,
+        bytes: Buffer.byteLength(content, "utf8"),
+        max_line_code_points: lengths.maximum,
+        long_lines: lengths.long,
+        references,
+        controlling_sources: controllingSources,
+        declarations: extracted.declarations,
+        invalid_declarations: extracted.invalid_declarations,
+    };
+}
+async function resolveReference(projectRoot, sourceFile, reference, catalogFiles, fileOverrides) {
+    const sourcePath = sourceFile.path;
+    const split = splitDestination(reference.destination);
+    if (split.disposition === "ignored")
+        return null;
+    if (split.disposition === "invalid")
+        return {
+            ...reference,
+            source_path: sourcePath,
+            target_path: null,
+            fragment: split.fragment,
+            status: "invalid",
+            detail: split.detail,
+        };
+    const normalizedDestination = split.local.replaceAll("\\", "/");
+    const lexicalAbsolute = normalizedDestination.startsWith("/")
+        ? path.resolve(projectRoot, normalizedDestination.slice(1))
+        : normalizedDestination.startsWith("project_context/")
+            ? path.resolve(projectRoot, normalizedDestination)
+            : path.resolve(path.dirname(sourceFile.absolute_path), normalizedDestination);
+    const targetPath = normalizeContextPath(path.relative(projectRoot, lexicalAbsolute));
+    if (!isPathWithin(projectRoot, lexicalAbsolute))
+        return {
+            ...reference,
+            source_path: sourcePath,
+            target_path: targetPath,
+            fragment: split.fragment,
+            status: "outside_repository",
+            detail: "local Markdown destination resolves outside the repository",
+        };
+    const catalogTarget = catalogFiles.get(targetPath);
+    if (fileOverrides?.has(targetPath)) {
+        if (fileOverrides.get(targetPath) === null)
+            return {
+                ...reference,
+                source_path: sourcePath,
+                target_path: targetPath,
+                fragment: split.fragment,
+                status: "missing",
+            };
+        if (!catalogTarget ||
+            !sameStagedAbsolutePath(lexicalAbsolute, catalogTarget.absolute_path))
+            return {
+                ...reference,
+                source_path: sourcePath,
+                target_path: targetPath,
+                fragment: split.fragment,
+                status: "missing",
+                detail: "local Markdown destination does not resolve to the staged target physical path",
+            };
+        return {
+            ...reference,
+            source_path: sourcePath,
+            target_path: targetPath,
+            fragment: split.fragment,
+            status: "valid",
+        };
+    }
+    try {
+        await lstat(lexicalAbsolute);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return {
+                ...reference,
+                source_path: sourcePath,
+                target_path: targetPath,
+                fragment: split.fragment,
+                status: "missing",
+            };
+        throw error;
+    }
+    const identity = await realpath(lexicalAbsolute);
+    if (!isPathWithin(await realpath(projectRoot), identity))
+        return {
+            ...reference,
+            source_path: sourcePath,
+            target_path: targetPath,
+            fragment: split.fragment,
+            status: "outside_repository",
+            detail: "local Markdown destination resolves through a link outside the repository",
+        };
+    if (catalogTarget) {
+        let catalogIdentity;
+        try {
+            catalogIdentity = await realpath(catalogTarget.absolute_path);
+        }
+        catch (error) {
+            if (isMissing(error))
+                return {
+                    ...reference,
+                    source_path: sourcePath,
+                    target_path: targetPath,
+                    fragment: split.fragment,
+                    status: "missing",
+                };
+            throw error;
+        }
+        if (!sameRealPath(identity, catalogIdentity))
+            return {
+                ...reference,
+                source_path: sourcePath,
+                target_path: targetPath,
+                fragment: split.fragment,
+                status: "invalid",
+                detail: "local Markdown destination resolves to a different physical file than its Catalog identity",
+            };
+    }
+    return {
+        ...reference,
+        source_path: sourcePath,
+        target_path: targetPath,
+        fragment: split.fragment,
+        status: "valid",
+    };
+}
+function sameStagedAbsolutePath(left, right) {
+    const normalizedLeft = path.resolve(left);
+    const normalizedRight = path.resolve(right);
+    return process.platform === "win32"
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
+function sameRealPath(left, right) {
+    return path.relative(left, right) === "";
+}
+function splitDestination(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+        return {
+            disposition: "ignored",
+            fragment: trimmed.slice(1) || null,
+        };
+    if (trimmed.startsWith("//") || /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(trimmed))
+        return { disposition: "ignored", fragment: null };
+    const fragmentIndex = trimmed.indexOf("#");
+    const queryIndex = trimmed.indexOf("?");
+    const boundary = [fragmentIndex, queryIndex]
+        .filter((entry) => entry >= 0)
+        .reduce((lowest, entry) => Math.min(lowest, entry), trimmed.length);
+    const encodedPath = trimmed.slice(0, boundary);
+    const fragment = fragmentIndex >= 0 ? trimmed.slice(fragmentIndex + 1) : null;
+    try {
+        return {
+            disposition: "local",
+            local: decodeURIComponent(encodedPath),
+            fragment,
+        };
+    }
+    catch {
+        return {
+            disposition: "invalid",
+            fragment,
+            detail: "local Markdown destination contains invalid URL encoding",
+        };
+    }
+}
+function lineLengths(content, threshold) {
+    let maximum = 0;
+    const long = [];
+    for (const [index, line] of content.split(/\r\n?|\n/u).entries()) {
+        const codePoints = Array.from(line).length;
+        maximum = Math.max(maximum, codePoints);
+        if (codePoints > threshold)
+            long.push({ line: index + 1, code_points: codePoints });
+    }
+    return { maximum, long };
+}
+function declarationConflicts(declarations) {
+    const groups = new Map();
+    for (const declaration of declarations) {
+        const key = `${declaration.type}\0${declaration.id}`;
+        groups.set(key, [...(groups.get(key) ?? []), declaration]);
+    }
+    const conflicts = [];
+    for (const declarationsForKey of groups.values()) {
+        const owners = new Map();
+        for (const declaration of declarationsForKey)
+            if (!owners.has(declaration.path))
+                owners.set(declaration.path, declaration.line);
+        if (owners.size < 2)
+            continue;
+        conflicts.push({
+            type: declarationsForKey[0].type,
+            id: declarationsForKey[0].id,
+            owners: [...owners.entries()]
+                .sort(([left], [right]) => compareUtf8Paths(left, right))
+                .map(([ownerPath, line]) => ({ path: ownerPath, line })),
+        });
+    }
+    return conflicts.sort((left, right) => compareUtf8Paths(`${left.type}:${left.id}`, `${right.type}:${right.id}`));
+}
+function isMissing(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/lib/context-markdown/context-markdown-extract.d.ts

@@ -0,0 +1,8 @@
+import type { ContextControllingSourceRawDeclaration, ContextInvalidDeclaration, ContextMarkdownRawReference, ContextStableKeyDeclaration } from "./context-markdown-types.js";
+export interface ContextMarkdownExtraction {
+    references: ContextMarkdownRawReference[];
+    controlling_sources: ContextControllingSourceRawDeclaration[];
+    declarations: ContextStableKeyDeclaration[];
+    invalid_declarations: ContextInvalidDeclaration[];
+}
+export declare function extractContextMarkdown(content: string, sourcePath: string): ContextMarkdownExtraction;

package/dist/lib/context-markdown/context-markdown-extract.js

@@ -0,0 +1,134 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+const DECLARATION = /^<!--\s*ty-context-declare\s+([A-Z][A-Za-z0-9]*-ID):\s*([A-Z][A-Z0-9]*(?:-[A-Z0-9]+)+)\s*-->$/u;
+const CONTROLLING_SOURCE_DECLARATION = /^<!-- ty-context-controlling-source domain="(product|technical|design|acceptance|external)" path="([^"]+)" -->$/u;
+export function extractContextMarkdown(content, sourcePath) {
+    const tree = fromMarkdown(content);
+    const references = [];
+    const controllingSources = [];
+    const declarations = [];
+    const invalidDeclarations = [];
+    walk(tree, (node) => {
+        const line = node.position?.start.line ?? 1;
+        const column = node.position?.start.column ?? 1;
+        if (node.type === "link")
+            references.push({
+                destination: node.url,
+                kind: "inline",
+                line,
+                column,
+            });
+        else if (node.type === "image")
+            references.push({
+                destination: node.url,
+                kind: "image",
+                line,
+                column,
+            });
+        else if (node.type === "definition")
+            references.push({
+                destination: node.url,
+                kind: "definition",
+                line,
+                column,
+            });
+        else if (node.type === "text") {
+            for (const angle of angleDestinations(node.value))
+                references.push({
+                    destination: angle.value,
+                    kind: "angle",
+                    line,
+                    column: column + angle.code_point_offset,
+                });
+        }
+        else if (node.type === "html") {
+            const raw = node.value.trim();
+            const declaration = DECLARATION.exec(raw);
+            const controllingSource = CONTROLLING_SOURCE_DECLARATION.exec(raw);
+            if (declaration)
+                declarations.push({
+                    type: declaration[1],
+                    id: declaration[2],
+                    path: sourcePath,
+                    line,
+                    column,
+                });
+            else if (controllingSource)
+                controllingSources.push({
+                    domain: controllingSource[1],
+                    declared_path: controllingSource[2],
+                    source_path: sourcePath,
+                    line,
+                    column,
+                });
+            else if (raw.includes("ty-context-controlling-source"))
+                invalidDeclarations.push({
+                    path: sourcePath,
+                    raw,
+                    line,
+                    column,
+                    reason: 'controlling Source declaration must exactly match <!-- ty-context-controlling-source domain="product|technical|design|acceptance|external" path="repository/file" --> with this attribute order',
+                });
+            else if (raw.includes("ty-context-declare"))
+                invalidDeclarations.push({
+                    path: sourcePath,
+                    raw,
+                    line,
+                    column,
+                    reason: "declaration must be an exact HTML comment with <Type-ID>: <UPPERCASE-ID-PARTS>",
+                });
+            else if (raw.startsWith("<") && raw.endsWith(">")) {
+                const destination = raw.slice(1, -1).trim();
+                if (looksLikeLocalAngle(destination))
+                    references.push({
+                        destination,
+                        kind: "angle",
+                        line,
+                        column,
+                    });
+            }
+        }
+    });
+    return {
+        references,
+        controlling_sources: controllingSources,
+        declarations,
+        invalid_declarations: invalidDeclarations,
+    };
+}
+function walk(node, visit) {
+    if (node.type !== "root")
+        visit(node);
+    if (!("children" in node))
+        return;
+    for (const child of node.children)
+        walk(child, visit);
+}
+function angleDestinations(value) {
+    const result = [];
+    const points = Array.from(value);
+    for (let index = 0; index < points.length; index += 1) {
+        if (points[index] !== "<")
+            continue;
+        const end = points.indexOf(">", index + 1);
+        if (end < 0)
+            break;
+        const candidate = points
+            .slice(index + 1, end)
+            .join("")
+            .trim();
+        if (looksLikeLocalAngle(candidate))
+            result.push({ value: candidate, code_point_offset: index });
+        index = end;
+    }
+    return result;
+}
+function looksLikeLocalAngle(value) {
+    if (!value || Array.from(value).some((point) => /\s/u.test(point)))
+        return false;
+    return (value.startsWith(".") ||
+        value.startsWith("/") ||
+        value.startsWith("project_context") ||
+        value.includes("/") ||
+        value.includes("\\") ||
+        value.toLowerCase().endsWith(".md"));
+}

package/dist/lib/context-markdown/context-markdown-types.d.ts

@@ -0,0 +1,83 @@
+export type ContextMarkdownReferenceKind = "inline" | "image" | "definition" | "angle";
+export type ContextMarkdownReferenceStatus = "valid" | "missing" | "outside_repository" | "invalid";
+export type ContextControllingSourceDomain = "product" | "technical" | "design" | "acceptance" | "external";
+export interface ContextMarkdownRawReference {
+    destination: string;
+    kind: ContextMarkdownReferenceKind;
+    line: number;
+    column: number;
+}
+export interface ContextMarkdownReference extends ContextMarkdownRawReference {
+    source_path: string;
+    target_path: string | null;
+    fragment: string | null;
+    status: ContextMarkdownReferenceStatus;
+    detail?: string;
+}
+export interface ContextControllingSourceRawDeclaration {
+    domain: ContextControllingSourceDomain;
+    declared_path: string;
+    source_path: string;
+    line: number;
+    column: number;
+}
+export interface ContextControllingSourceDeclaration extends ContextControllingSourceRawDeclaration {
+    target_path: string | null;
+    status: ContextMarkdownReferenceStatus;
+    detail?: string;
+}
+export interface ContextControllingSourceConflict {
+    kind: "duplicate" | "domain_conflict";
+    target_path: string;
+    domains: ContextControllingSourceDomain[];
+    owners: Array<{
+        source_path: string;
+        line: number;
+        domain: ContextControllingSourceDomain;
+    }>;
+}
+export interface ContextStableKeyDeclaration {
+    type: string;
+    id: string;
+    path: string;
+    line: number;
+    column: number;
+}
+export interface ContextInvalidDeclaration {
+    path: string;
+    raw: string;
+    line: number;
+    column: number;
+    reason: string;
+}
+export interface ContextLongLine {
+    line: number;
+    code_points: number;
+}
+export interface ContextMarkdownFileAnalysis {
+    path: string;
+    bytes: number;
+    max_line_code_points: number;
+    long_lines: ContextLongLine[];
+    references: ContextMarkdownReference[];
+    controlling_sources: ContextControllingSourceDeclaration[];
+    declarations: ContextStableKeyDeclaration[];
+    invalid_declarations: ContextInvalidDeclaration[];
+}
+export interface ContextStableKeyConflict {
+    type: string;
+    id: string;
+    owners: Array<{
+        path: string;
+        line: number;
+    }>;
+}
+export interface ContextMarkdownCatalogAnalysis {
+    files: ContextMarkdownFileAnalysis[];
+    references: ContextMarkdownReference[];
+    controlling_sources: ContextControllingSourceDeclaration[];
+    controlling_source_conflicts: ContextControllingSourceConflict[];
+    declarations: ContextStableKeyDeclaration[];
+    invalid_declarations: ContextInvalidDeclaration[];
+    declaration_conflicts: ContextStableKeyConflict[];
+}

package/dist/lib/context-move/context-move-input.d.ts

@@ -0,0 +1,8 @@
+export interface NormalizedContextMoveInput {
+    from_path: string;
+    to_path: string;
+}
+export declare function normalizeContextMoveInput(input: {
+    from_path: string;
+    to_path: string;
+}): NormalizedContextMoveInput;

package/dist/lib/context-move/context-move-input.js

@@ -0,0 +1,17 @@
+import { CLI_EXIT_CODES, CliCommandError } from "../cli-exit.js";
+import { normalizeContextFilePath } from "../context-create/context-create-path.js";
+export function normalizeContextMoveInput(input) {
+    const from = normalizeContextFilePath(input.from_path, "context move --from");
+    const to = normalizeContextFilePath(input.to_path, "context move --to");
+    if (from === to)
+        invalid("context move --from and --to must be different paths");
+    if (fold(from) === fold(to))
+        invalid("context move does not support case-only path changes");
+    return { from_path: from, to_path: to };
+}
+function fold(value) {
+    return value.normalize("NFC").toLocaleLowerCase("en-US");
+}
+function invalid(message) {
+    throw new CliCommandError(CLI_EXIT_CODES.arguments, message);
+}

package/dist/lib/context-move/context-move-literal-scan.d.ts

@@ -0,0 +1,20 @@
+export interface ContextMoveLiteralMatch {
+    path: string;
+    line: number;
+    column: number;
+    matched: string;
+    kind: "markdown_non_link" | "code_or_config";
+}
+export interface ContextMoveLiteralScan {
+    complete: boolean;
+    files_scanned: number;
+    bytes_scanned: number;
+    matches: ContextMoveLiteralMatch[];
+    limits_exceeded: string[];
+}
+export declare function scanStagedRepositoryForContextPath(input: {
+    repository: string;
+    logical_context_path: string;
+    physical_context_path: string;
+    file_overrides: ReadonlyMap<string, Uint8Array | null>;
+}): Promise<ContextMoveLiteralScan>;