project-tiny-context-harness 0.2.60 → 0.2.62

package/dist/commands/export-context.js

@@ -1,4 +1,6 @@
+import { parseArgs, helpText } from "./export-context-args.js";
 import { runExportContext } from "../lib/context-export.js";
+import { runSourcePackExport } from "../lib/source-pack-export.js";
 export async function exportContext(args) {
     let parsed;
     try {
@@ -9,7 +11,7 @@ export async function exportContext(args) {
         process.exitCode = 1;
         return;
     }
-    if (parsed.help || (!parsed.full && !parsed.code && !parsed.all)) {
+    if (parsed.help || (!parsed.full && !parsed.code && !parsed.all && !parsed.sourceMode)) {
         console.log(helpText());
         if (!parsed.help) {
             process.exitCode = 1;
@@ -17,32 +19,25 @@ export async function exportContext(args) {
         return;
     }
     try {
-        if (parsed.all) {
-            const now = new Date();
-            const fullReport = await runExportContext(process.cwd(), {
-                full: true,
-                check: parsed.check,
-                now
-            });
-            const codeReport = await runExportContext(process.cwd(), {
-                code: true,
+        if (parsed.sourceMode) {
+            printSourcePackReport(await runSourcePackExport(process.cwd(), {
+                mode: parsed.sourceMode,
                 check: parsed.check,
-                now
-            });
-            console.log(parsed.check ? "export-context check OK" : "export-context wrote artifacts");
-            console.log("mode: all");
-            console.log("outputs:");
-            console.log(`- full: ${fullReport.outputRelativePath}`);
-            console.log(`- code: ${codeReport.outputRelativePath}`);
-            console.log(`source context count: ${fullReport.sourceContextCount}`);
-            console.log(`source code count: ${codeReport.sourceCodeCount ?? codeReport.sourceFiles.length}`);
-            console.log(`total code lines: ${codeReport.totalLines ?? 0}`);
-            console.log(`total code characters: ${codeReport.totalCharacters ?? 0}`);
-            console.log("warnings:");
-            printWarnings([
-                ...fullReport.warnings.map((warning) => `full: ${warning}`),
-                ...codeReport.warnings.map((warning) => `code: ${warning}`)
-            ]);
+                command: `ty-context export-context ${args.join(" ")}`.trim(),
+                profile: parsed.profile,
+                includeContext: parsed.includeContext,
+                includeCode: parsed.includeCode,
+                bundleStrategy: parsed.bundleStrategy,
+                maxPackFiles: parsed.maxPackFiles,
+                maxBundleCharacters: parsed.maxBundleCharacters,
+                redactionStrict: parsed.redactionStrict,
+                prune: parsed.prune,
+                taskName: parsed.taskName
+            }), parsed.check);
+            return;
+        }
+        if (parsed.all) {
+            await runLegacyAll(parsed.check);
             return;
         }
         const report = await runExportContext(process.cwd(), {
@@ -74,57 +69,42 @@ export async function exportContext(args) {
         process.exitCode = 1;
     }
 }
-function parseArgs(args) {
-    const parsed = { full: false, code: false, all: false, check: false, help: false };
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--full") {
-            parsed.full = true;
-            continue;
-        }
-        if (arg === "--code") {
-            parsed.code = true;
-            continue;
-        }
-        if (arg === "--all") {
-            parsed.all = true;
-            continue;
-        }
-        if (arg === "--check") {
-            parsed.check = true;
-            continue;
-        }
-        if (arg === "--help" || arg === "-h") {
-            parsed.help = true;
-            continue;
-        }
-        if (arg === "--output") {
-            const value = args[index + 1];
-            if (!value || value.startsWith("--")) {
-                throw new Error("export-context --output requires a path");
-            }
-            parsed.output = value;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith("--output=")) {
-            const value = arg.slice("--output=".length).trim();
-            if (!value) {
-                throw new Error("export-context --output requires a path");
-            }
-            parsed.output = value;
-            continue;
-        }
-        throw new Error(`unknown export-context argument: ${arg}`);
-    }
-    const modeCount = Number(parsed.full) + Number(parsed.code) + Number(parsed.all);
-    if (modeCount > 1) {
-        throw new Error("export-context accepts exactly one of --full, --code or --all");
+async function runLegacyAll(check) {
+    const now = new Date();
+    const fullReport = await runExportContext(process.cwd(), { full: true, check, now });
+    const codeReport = await runExportContext(process.cwd(), { code: true, check, now });
+    console.log(check ? "export-context check OK" : "export-context wrote artifacts");
+    console.log("mode: all");
+    console.log("outputs:");
+    console.log(`- full: ${fullReport.outputRelativePath}`);
+    console.log(`- code: ${codeReport.outputRelativePath}`);
+    console.log(`source context count: ${fullReport.sourceContextCount}`);
+    console.log(`source code count: ${codeReport.sourceCodeCount ?? codeReport.sourceFiles.length}`);
+    console.log(`total code lines: ${codeReport.totalLines ?? 0}`);
+    console.log(`total code characters: ${codeReport.totalCharacters ?? 0}`);
+    console.log("warnings:");
+    printWarnings([
+        ...fullReport.warnings.map((warning) => `full: ${warning}`),
+        ...codeReport.warnings.map((warning) => `code: ${warning}`)
+    ]);
+}
+function printSourcePackReport(report, check) {
+    console.log(check ? "export-context check OK" : "export-context wrote artifacts");
+    console.log(`mode: ${report.mode}`);
+    console.log(`output directory: ${report.outputRelativePath}`);
+    console.log(`source code count: ${report.sourceCodeCount}`);
+    console.log(`total lines: ${report.totalLines}`);
+    console.log(`total characters: ${report.totalCharacters}`);
+    console.log("artifacts:");
+    for (const artifact of report.artifacts) {
+        console.log(`- ${artifact.kind}: ${artifact.path} (${artifact.characters} chars, ${artifact.source_count} sources)`);
     }
-    if (parsed.all && parsed.output) {
-        throw new Error("export-context --all writes two default artifacts; --output is only supported with --full or --code");
+    console.log("recommended upload sets:");
+    for (const [name, files] of Object.entries(report.recommendedUploadSets)) {
+        console.log(`- ${name}: ${files.join(", ")}`);
     }
-    return parsed;
+    console.log("warnings:");
+    printWarnings(report.warnings);
 }
 function printWarnings(warnings) {
     if (warnings.length === 0) {
@@ -135,15 +115,3 @@ function printWarnings(warnings) {
         console.log(`- ${warning}`);
     }
 }
-function helpText() {
-    return `ty-context export-context:
-  export-context --full [--output tmp/ty-context/context-exports/<name>.md] [--check]
-  export-context --code [--output tmp/ty-context/context-exports/<name>.md] [--check]
-  export-context --all [--check]
-
-Creates temporary Markdown artifacts for copying or external-tool ingestion.
---full exports the project Context summary as a full-project-context artifact.
---code exports one current implementation snapshot as a code-level-implementation artifact.
---all exports both default artifacts in one command.
-The artifact must stay under tmp/ty-context/context-exports/** and must not be referenced from project_context/context.toml.`;
-}

package/dist/commands/index.js

@@ -30,8 +30,8 @@ export function help() {
   doctor               Diagnose project configuration and drift
   check-modularity --touched|--file <path>|--base <ref> [--limit 300] [--fail-on-warning]
                        Warn when selected handwritten source files exceed a line-count limit
-  export-context --full|--code|--all [--output <path>] [--check]
-                       Export a temporary Context summary or code implementation Markdown artifact
+  export-context --full|--code|--all|--source-pack|--code-index|--task-context
+                       Export temporary Context, code snapshot or bounded Source Pack artifacts
   validate <gate>      Run a Harness validation gate
   validate-context     Validate Minimal Context fact-source recoverability
   validate-code-modularity

package/dist/lib/source-pack-classify.d.ts

@@ -0,0 +1,10 @@
+import type { ContextAreaMapping } from "./source-pack-types.js";
+export interface CodeClassification {
+    language: string;
+    summary: string;
+    tags: string[];
+    routes: string[];
+    score: number;
+    bucket: string;
+}
+export declare function classifyCodeFile(relative: string, content: string, areas: ContextAreaMapping[]): CodeClassification;

package/dist/lib/source-pack-classify.js

@@ -0,0 +1,142 @@
+import path from "node:path";
+import { SAFE_EXAMPLE_FILE_NAMES } from "./source-files.js";
+const OVERSIZED_LINES = 1000;
+const OVERSIZED_CHARACTERS = 50_000;
+export function classifyCodeFile(relative, content, areas) {
+    const language = languageFor(relative) || "text";
+    const routes = extractRouteSummary(content);
+    const tags = tagsFor(relative, content, language, routes);
+    return {
+        language,
+        summary: summarizeCodeFile(relative, content, language),
+        tags,
+        routes,
+        score: scoreFor(tags, relative),
+        bucket: routingBucket(relative, areas)
+    };
+}
+function tagsFor(relative, content, language, routes) {
+    const lower = relative.toLowerCase();
+    const tags = new Set();
+    const lines = content.length === 0 ? 0 : content.split(/\r\n|\r|\n/).length;
+    if (isLikelyEntrypoint(relative))
+        tags.add("entry");
+    if (routes.length > 0 || /route|controller|api/.test(lower))
+        tags.add("api");
+    if (/cli|commands|bin\//.test(lower))
+        tags.add("cli");
+    if (/worker|scheduler|queue|runtime|cron|job/.test(lower))
+        tags.add("worker");
+    if (/schema|contract|types?\.|\.d\.ts$/.test(lower) || /\b(interface|type|schema)\b/.test(content))
+        tags.add("contract");
+    if (/pages|views|screens|components|\.vue$|\.tsx$|\.jsx$/.test(lower))
+        tags.add("ui");
+    if (/test|spec|verification|makefile/.test(lower))
+        tags.add("test");
+    if (["json", "yaml", "toml", "make", "dockerfile"].includes(language))
+        tags.add("config");
+    if (lines > OVERSIZED_LINES || content.length > OVERSIZED_CHARACTERS)
+        tags.add("oversized");
+    return [...tags].sort();
+}
+function scoreFor(tags, relative) {
+    const weights = { entry: 50, api: 35, cli: 32, worker: 30, contract: 28, ui: 24, test: 18, config: 12, oversized: -15 };
+    return tags.reduce((sum, tag) => sum + (weights[tag] ?? 0), 0) + Math.max(0, 20 - relative.split("/").length);
+}
+function routingBucket(relative, areas) {
+    for (const area of areas) {
+        if (area.root === "." || relative === area.root || relative.startsWith(`${area.root}/`)) {
+            return `area:${area.id}`;
+        }
+    }
+    const parts = relative.split("/");
+    for (const prefix of ["domains", "apps", "services", "packages", "tools"]) {
+        if (parts[0] === prefix && parts[1]) {
+            return `${prefix}:${parts[1]}`;
+        }
+    }
+    return parts[0] || "misc";
+}
+function summarizeCodeFile(relative, content, language) {
+    const base = path.posix.basename(relative);
+    const symbols = extractSymbolSummary(content, language);
+    if (base === "package.json") {
+        const packageName = /"name"\s*:\s*"([^"]+)"/.exec(content)?.[1];
+        return packageName ? `Defines npm package ${packageName} metadata, scripts and dependencies.` : "Defines npm package metadata, scripts and dependencies.";
+    }
+    if (base.toLowerCase() === "makefile") {
+        const targets = [...content.matchAll(/^([A-Za-z0-9_.-]+):/gm)].map((match) => match[1]).slice(0, 6);
+        return targets.length > 0 ? `Defines Make targets ${targets.join(", ")}.` : "Defines Make targets for local automation.";
+    }
+    if (symbols.length > 0) {
+        return `${describeFilePurpose(relative, language)}; exposes ${symbols.slice(0, 6).join(", ")}.`;
+    }
+    return `${describeFilePurpose(relative, language)}.`;
+}
+function extractSymbolSummary(content, language) {
+    const patterns = language === "python"
+        ? [/^(?:async\s+)?def\s+([A-Za-z_][\w]*)/gm, /^class\s+([A-Za-z_][\w]*)/gm]
+        : language === "go"
+            ? [/^func\s+(?:\([^)]+\)\s*)?([A-Za-z_][\w]*)/gm, /^type\s+([A-Za-z_][\w]*)/gm]
+            : [
+                /(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g,
+                /(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/g,
+                /(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/g,
+                /(?:export\s+)?type\s+([A-Za-z_$][\w$]*)/g,
+                /(?:export\s+)?const\s+([A-Za-z_$][\w$]*)/g
+            ];
+    const symbols = new Set();
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(content)) && symbols.size < 10)
+            symbols.add(match[1]);
+    }
+    for (const route of extractRouteSummary(content)) {
+        if (symbols.size < 10)
+            symbols.add(route);
+    }
+    return [...symbols];
+}
+function extractRouteSummary(content) {
+    const routes = new Set();
+    const patterns = [/\.(get|post|put|patch|delete|head|options)\s*\(\s*["'`]([^"'`]+)["'`]/gi, /\bHandle(?:Func)?\s*\(\s*["'`]([^"'`]+)["'`]/g];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(content)) && routes.size < 8) {
+            routes.add(match.length === 3 ? `${match[1].toUpperCase()} ${match[2]}` : `route ${match[1]}`);
+        }
+    }
+    return [...routes].sort();
+}
+function describeFilePurpose(relative, language) {
+    const lower = relative.toLowerCase();
+    if (lower.includes("/test") || lower.includes(".test.") || lower.includes(".spec."))
+        return `Contains ${language} tests for ${path.posix.basename(relative)}`;
+    if (lower.includes("/commands/"))
+        return `Implements ${language} command handling for ${path.posix.basename(relative)}`;
+    if (lower.includes("/cli") || lower.endsWith("/cli.ts") || lower.endsWith("/cli.js"))
+        return `Implements ${language} CLI behavior for ${path.posix.basename(relative)}`;
+    if (lower.includes("/components/") || lower.includes("/pages/") || lower.includes("/views/"))
+        return `Implements ${language} UI behavior for ${path.posix.basename(relative)}`;
+    return `Contains ${language} implementation for ${path.posix.basename(relative)}`;
+}
+function isLikelyEntrypoint(relative) {
+    const lower = relative.toLowerCase();
+    const base = path.posix.basename(lower);
+    return ["package.json", "makefile", "dockerfile", "main.go", "app.py", "server.py", "index.ts", "index.js", "cli.ts", "cli.js"].includes(base) || /\/src\/(main|app|index)\.[tj]sx?$/.test(lower);
+}
+function languageFor(relative) {
+    const lower = relative.toLowerCase();
+    const base = path.posix.basename(lower);
+    if (base === "makefile")
+        return "make";
+    if (base === "dockerfile" || base.startsWith("dockerfile.") || lower.endsWith(".dockerfile"))
+        return "dockerfile";
+    if (SAFE_EXAMPLE_FILE_NAMES.has(base))
+        return "dotenv";
+    for (const [extension, language] of [[".tsx", "tsx"], [".ts", "typescript"], [".jsx", "jsx"], [".js", "javascript"], [".mjs", "javascript"], [".py", "python"], [".go", "go"], [".vue", "vue"], [".sql", "sql"], [".json", "json"], [".jsonc", "jsonc"], [".yaml", "yaml"], [".yml", "yaml"], [".toml", "toml"], [".sh", "bash"], [".ps1", "powershell"], [".cmd", "batch"], [".bat", "batch"], [".graphql", "graphql"], [".gql", "graphql"], [".proto", "protobuf"]]) {
+        if (lower.endsWith(extension))
+            return language;
+    }
+    return "";
+}

package/dist/lib/source-pack-config.d.ts

@@ -0,0 +1,7 @@
+import type { ContextAreaMapping, SourcePackProfile } from "./source-pack-types.js";
+export declare function readSourcePackProfile(projectRoot: string, profileId?: string): Promise<SourcePackProfile>;
+export declare function parseContextAreas(projectRoot: string): Promise<ContextAreaMapping[]>;
+export declare function mergePatterns(...groups: Array<string[] | undefined>): string[];
+export declare function validatePatternList(values: string[], label: string): string[];
+export declare function matchesAny(relative: string, patterns: string[]): boolean;
+export declare function normalizeRepoPath(value: string, label: string): string;

package/dist/lib/source-pack-config.js

@@ -0,0 +1,93 @@
+import path from "node:path";
+import { harnessConfigPath } from "./harness-root.js";
+import { pathExists, readText } from "./fs.js";
+import { parseYaml } from "./yaml.js";
+import { toPosix } from "./source-files.js";
+export async function readSourcePackProfile(projectRoot, profileId) {
+    if (!profileId) {
+        return { context: [], code: [], exclude: [], verification: [] };
+    }
+    const configPath = path.join(projectRoot, await harnessConfigPath(projectRoot));
+    if (!(await pathExists(configPath))) {
+        throw new Error(`source pack profile not found: ${profileId}`);
+    }
+    const parsed = parseYaml(await readText(configPath));
+    const sourcePacks = parsed && typeof parsed === "object" ? parsed.source_packs : undefined;
+    const profileValue = sourcePacks && typeof sourcePacks === "object" ? sourcePacks[profileId] : undefined;
+    if (!profileValue || typeof profileValue !== "object" || Array.isArray(profileValue)) {
+        throw new Error(`source pack profile not found: ${profileId}`);
+    }
+    const value = profileValue;
+    return {
+        context: readPatternList(value.context, `source_packs.${profileId}.context`, "context path"),
+        code: readPatternList(value.code, `source_packs.${profileId}.code`, "code path"),
+        exclude: readPatternList(value.exclude, `source_packs.${profileId}.exclude`, "exclude path"),
+        verification: readStringList(value.verification, `source_packs.${profileId}.verification`),
+        maxBundleCharacters: readPositiveInteger(value.max_bundle_characters, `source_packs.${profileId}.max_bundle_characters`)
+    };
+}
+export async function parseContextAreas(projectRoot) {
+    const manifestPath = path.join(projectRoot, "project_context", "context.toml");
+    if (!(await pathExists(manifestPath))) {
+        return [];
+    }
+    const content = await readText(manifestPath);
+    const areas = [];
+    for (const block of content.split(/\[\[areas\]\]/g).slice(1)) {
+        const id = /id\s*=\s*"([^"]+)"/.exec(block)?.[1];
+        const root = /root\s*=\s*"([^"]+)"/.exec(block)?.[1];
+        const context = /context\s*=\s*"([^"]+)"/.exec(block)?.[1];
+        if (id && root && context) {
+            areas.push({ id, root: normalizeRepoPath(root, "area root"), context: normalizeRepoPath(context, "area context") });
+        }
+    }
+    return areas.sort((left, right) => left.id.localeCompare(right.id));
+}
+export function mergePatterns(...groups) {
+    return [...new Set(groups.flatMap((group) => group ?? []).map((value) => normalizeRepoPath(value, "include path")))].sort();
+}
+export function validatePatternList(values, label) {
+    return values.map((value) => normalizeRepoPath(value, label));
+}
+export function matchesAny(relative, patterns) {
+    return patterns.some((pattern) => globToRegExp(pattern).test(relative));
+}
+export function normalizeRepoPath(value, label) {
+    const normalized = toPosix(value.trim()).replace(/^\.\//, "");
+    if (!isAllowedPatternPath(normalized)) {
+        throw new Error(`${label} must be repo-relative and stay inside the workspace: ${value}`);
+    }
+    return normalized;
+}
+function readPatternList(value, label, pathLabel) {
+    return readStringList(value, label).map((item) => normalizeRepoPath(item, pathLabel));
+}
+function readStringList(value, label) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim().length === 0)) {
+        throw new Error(`<harnessRoot>/config.yaml ${label} must be an array of non-empty strings`);
+    }
+    return value.map((item) => item.trim());
+}
+function readPositiveInteger(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(value) || Number(value) <= 0) {
+        throw new Error(`<harnessRoot>/config.yaml ${label} must be a positive integer`);
+    }
+    return Number(value);
+}
+function isAllowedPatternPath(value) {
+    return value.length > 0 && !path.posix.isAbsolute(value) && !value.split("/").includes("..");
+}
+function globToRegExp(pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, "\0")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\0/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}

package/dist/lib/source-pack-export.d.ts

@@ -0,0 +1,2 @@
+import type { SourcePackOptions, SourcePackReport } from "./source-pack-types.js";
+export declare function runSourcePackExport(projectRoot: string, options: SourcePackOptions): Promise<SourcePackReport>;