project-tiny-context-harness 0.2.60 → 0.2.62

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

@@ -0,0 +1,223 @@
+import path from "node:path";
+import { artifactReport, buildManifest, pruneTimestampedExports, readPackageVersion, timestampForFile, writeArtifactSet } from "./source-pack-manifest.js";
+import { mergePatterns, parseContextAreas, readSourcePackProfile, validatePatternList } from "./source-pack-config.js";
+import { collectCodeRecords, collectContextArtifacts, countRedactionWarnings, repoRelative } from "./source-pack-records.js";
+import { renderBundleArtifact, renderCodeIndexArtifact, renderFullProjectContextArtifact, renderTaskContextArtifact } from "./source-pack-render.js";
+const DEFAULT_EXPORT_DIR = "tmp/ty-context/context-exports";
+const DEFAULT_MAX_PACK_FILES = 5;
+const DEFAULT_MAX_BUNDLE_CHARACTERS = 800_000;
+export async function runSourcePackExport(projectRoot, options) {
+    const maxPackFiles = options.maxPackFiles ?? DEFAULT_MAX_PACK_FILES;
+    validateMaxPackFiles(options.mode, maxPackFiles);
+    const now = options.now ?? new Date();
+    const timestamp = timestampForFile(now);
+    const timestampDir = path.join(projectRoot, ...DEFAULT_EXPORT_DIR.split("/"), timestamp);
+    const generatedAt = now.toISOString();
+    const warnings = [];
+    const areas = await parseContextAreas(projectRoot);
+    const profile = await readSourcePackProfile(projectRoot, options.profile);
+    const includeCode = mergePatterns(profile.code, validatePatternList(options.includeCode ?? [], "include code path"));
+    const includeContext = mergePatterns(profile.context, validatePatternList(options.includeContext ?? [], "include context path"));
+    const exclude = mergePatterns(profile.exclude);
+    const maxBundleCharacters = options.maxBundleCharacters ?? profile.maxBundleCharacters ?? DEFAULT_MAX_BUNDLE_CHARACTERS;
+    const bundleStrategy = options.bundleStrategy ?? "auto";
+    const records = await collectCodeRecords(projectRoot, warnings, {
+        include: includeCode.length > 0 ? includeCode : undefined,
+        exclude,
+        areas
+    });
+    const contexts = await collectContextArtifacts(projectRoot, warnings, options.mode === "task-context" && includeContext.length > 0 ? includeContext : undefined);
+    const taskName = options.taskName ?? "";
+    const command = options.command ?? commandFor(options);
+    const toolVersion = await readPackageVersion();
+    const recommendedUploadSets = uploadSets(options.mode, timestamp, taskName);
+    const artifacts = [];
+    if (options.mode === "code-index" || options.mode === "source-pack" || options.mode === "code-bundles" || options.mode === "task-context") {
+        assignBundles(records, maxBundleCharacters, bundleStrategy);
+        artifacts.push(markdownArtifact("code-index", "code-index.md", renderCodeIndexArtifact(records, areas, warnings, meta(generatedAt, "code-index.md", command, toolVersion)), records.length, sumLines(records), warnings.length));
+    }
+    if (options.mode === "source-pack" || options.mode === "task-context") {
+        artifacts.splice(0, 0, markdownArtifact("full-project-context", "full-project-context.md", renderFullProjectContextArtifact(contexts, warnings, meta(generatedAt, "full-project-context.md", command, toolVersion)), contexts.length, sumContextLines(contexts), warnings.length));
+    }
+    if (options.mode === "source-pack" || options.mode === "code-bundles") {
+        addDefaultBundles(artifacts, records, contexts, maxPackFiles, warnings, generatedAt, command, toolVersion);
+    }
+    if (options.mode === "task-context") {
+        addTaskArtifacts(artifacts, records, contexts, profile.verification, maxPackFiles, warnings, generatedAt, command, toolVersion, taskName, maxBundleCharacters, bundleStrategy);
+    }
+    const omitted = omittedSummary(records);
+    const nonManifestArtifacts = artifacts.slice();
+    const manifestPath = `${DEFAULT_EXPORT_DIR}/${timestamp}/source-pack-manifest.json`;
+    const manifest = await buildManifest({
+        projectRoot,
+        generatedAt,
+        command,
+        maxPackFiles,
+        artifacts: nonManifestArtifacts.map((artifact) => ({ ...artifact, relativePath: `${DEFAULT_EXPORT_DIR}/${timestamp}/${artifact.name}` })),
+        warnings,
+        omitted,
+        recommendedUploadSets
+    });
+    artifacts.unshift({
+        kind: "manifest",
+        name: "source-pack-manifest.json",
+        relativePath: manifestPath,
+        content: manifest,
+        sourceCount: 0,
+        sourceLineCount: 0,
+        warningCount: warnings.length
+    });
+    for (const artifact of artifacts) {
+        if (!artifact.relativePath) {
+            artifact.relativePath = `${DEFAULT_EXPORT_DIR}/${timestamp}/${artifact.name}`;
+        }
+    }
+    if (artifacts.length > maxPackFiles) {
+        throw new Error(`Source Pack mode ${options.mode} planned ${artifacts.length} files; max is ${maxPackFiles}`);
+    }
+    const redactionCount = countRedactionWarnings(warnings);
+    if (options.redactionStrict && redactionCount > 0) {
+        throw new Error(`export-context --redaction-strict found ${redactionCount} redaction warning(s)`);
+    }
+    if (!options.check) {
+        await writeArtifactSet(projectRoot, timestampDir, artifacts);
+        if (options.prune !== undefined) {
+            await pruneTimestampedExports(projectRoot, options.prune);
+        }
+    }
+    return {
+        mode: options.mode,
+        outputDirectory: timestampDir,
+        outputRelativePath: repoRelative(projectRoot, timestampDir),
+        artifacts: artifacts.map(artifactReport),
+        sourceFiles: records.map((record) => record.relative),
+        sourceCodeCount: records.length,
+        totalLines: sumLines(records),
+        totalCharacters: records.reduce((sum, record) => sum + record.characters, 0),
+        redactionCount,
+        warnings,
+        omitted,
+        recommendedUploadSets,
+        wrote: !options.check
+    };
+}
+function addDefaultBundles(artifacts, records, contexts, maxPackFiles, warnings, generatedAt, command, toolVersion) {
+    const omitted = omittedSummary(records);
+    const slots = maxPackFiles - artifacts.length - 1;
+    const core = records.filter((record) => record.bundle === "core");
+    const extended = records.filter((record) => record.bundle === "extended");
+    if (slots >= 1 && core.length > 0) {
+        artifacts.push(markdownArtifact("code-bundle-core", "code-bundle-core.md", renderBundleArtifact("Code Bundle Core", core, contexts, omitted, warnings, meta(generatedAt, "code-bundle-core.md", command, toolVersion), "Deterministic score-first selection of entry/API/CLI/contract/UI/test files; routing buckets are export routing only."), core.length, sumLines(core), warnings.length));
+    }
+    if (slots >= 2 && extended.length > 0) {
+        artifacts.push(markdownArtifact("code-bundle-extended", "code-bundle-extended.md", renderBundleArtifact("Code Bundle Extended", extended, contexts, omitted, warnings, meta(generatedAt, "code-bundle-extended.md", command, toolVersion), "Next highest deterministic scores after core bundle until the bundle character budget is reached."), extended.length, sumLines(extended), warnings.length));
+    }
+}
+function addTaskArtifacts(artifacts, records, contexts, verification, maxPackFiles, warnings, generatedAt, command, toolVersion, taskName, maxBundleCharacters, bundleStrategy) {
+    const slug = taskSlug(taskName);
+    const sorted = sortedRecords(records, bundleStrategy);
+    assignTaskBundles(sorted, maxBundleCharacters);
+    const taskRecords = sorted.filter((record) => record.bundle === "task");
+    const supportRecords = sorted.filter((record) => record.bundle === "task-support");
+    const omitted = omittedSummary(sorted);
+    artifacts.push(markdownArtifact("task-context", `task-contexts/task-context-${slug}.md`, renderTaskContextArtifact(taskName, contexts, taskRecords, verification, omitted, warnings, meta(generatedAt, `task-contexts/task-context-${slug}.md`, command, toolVersion)), contexts.length + taskRecords.length, sumContextLines(contexts) + sumLines(taskRecords), warnings.length));
+    const slots = maxPackFiles - artifacts.length - 1;
+    if (slots >= 1 && supportRecords.length > 0) {
+        artifacts.push(markdownArtifact("code-bundle-task-support", "code-bundle-task-support.md", renderBundleArtifact("Code Bundle Task Support", supportRecords, contexts, omitted, warnings, meta(generatedAt, "code-bundle-task-support.md", command, toolVersion), "Deterministic support files selected after the main task-context body."), supportRecords.length, sumLines(supportRecords), warnings.length));
+    }
+}
+function assignBundles(records, maxCharacters, bundleStrategy) {
+    let coreCharacters = 0;
+    let extendedCharacters = 0;
+    for (const record of sortedRecords(records, bundleStrategy)) {
+        if (coreCharacters + record.characters <= maxCharacters) {
+            record.bundle = "core";
+            coreCharacters += record.characters;
+        }
+        else if (extendedCharacters + record.characters <= maxCharacters) {
+            record.bundle = "extended";
+            extendedCharacters += record.characters;
+        }
+        else {
+            record.bundle = "omitted";
+        }
+    }
+}
+function assignTaskBundles(records, maxCharacters) {
+    let taskCharacters = 0;
+    let supportCharacters = 0;
+    for (const record of records) {
+        if (taskCharacters + record.characters <= maxCharacters) {
+            record.bundle = "task";
+            taskCharacters += record.characters;
+        }
+        else if (supportCharacters + record.characters <= maxCharacters) {
+            record.bundle = "task-support";
+            supportCharacters += record.characters;
+        }
+        else {
+            record.bundle = "omitted";
+        }
+    }
+}
+function sortedRecords(records, bundleStrategy) {
+    return [...records].sort((left, right) => {
+        if (bundleStrategy === "area" || bundleStrategy === "config") {
+            return left.bucket.localeCompare(right.bucket) || right.score - left.score || left.relative.localeCompare(right.relative);
+        }
+        if (bundleStrategy === "topdir") {
+            return topDir(left).localeCompare(topDir(right)) || right.score - left.score || left.relative.localeCompare(right.relative);
+        }
+        return right.score - left.score || left.bucket.localeCompare(right.bucket) || left.relative.localeCompare(right.relative);
+    });
+}
+function topDir(record) {
+    return record.relative.split("/")[0] || ".";
+}
+function omittedSummary(records) {
+    const omitted = records.filter((record) => record.bundle === "omitted");
+    return { source_file_count: omitted.length, reason_counts: omitted.length > 0 ? { bundle_budget: omitted.length } : {} };
+}
+function markdownArtifact(kind, name, content, sourceCount, sourceLineCount, warningCount) {
+    return { kind, name, relativePath: "", content, sourceCount, sourceLineCount, warningCount };
+}
+function meta(generatedAt, artifactName, command, toolVersion) {
+    return { generatedAt, outputPath: `tmp/ty-context/context-exports/latest/${artifactName}`, command, toolVersion };
+}
+function uploadSets(mode, timestamp, taskName) {
+    const base = `${DEFAULT_EXPORT_DIR}/${timestamp}`;
+    const sets = {
+        daily_planning: [`${base}/full-project-context.md`, `${base}/code-index.md`],
+        cross_module_review: [`${base}/full-project-context.md`, `${base}/code-index.md`, `${base}/code-bundle-core.md`, `${base}/code-bundle-extended.md`],
+        full_fallback: [`${base}/full-project-context.md`, `${base}/code-index.md`, `${DEFAULT_EXPORT_DIR}/code-level-implementation-<timestamp>/code-level-implementation.md`]
+    };
+    if (mode === "task-context") {
+        sets.focused_task_handoff = [`${base}/full-project-context.md`, `${base}/code-index.md`, `${base}/task-contexts/task-context-${taskSlug(taskName)}.md`];
+    }
+    return sets;
+}
+function validateMaxPackFiles(mode, maxPackFiles) {
+    if (!Number.isInteger(maxPackFiles) || maxPackFiles <= 0) {
+        throw new Error("export-context --max-pack-files requires a positive integer");
+    }
+    if (maxPackFiles > DEFAULT_MAX_PACK_FILES) {
+        throw new Error("export-context --max-pack-files cannot exceed 5 for Source Pack modes");
+    }
+    const required = mode === "code-index" ? 2 : mode === "task-context" ? 4 : mode === "code-bundles" ? 3 : 3;
+    if (maxPackFiles < required) {
+        throw new Error(`export-context ${mode} requires --max-pack-files >= ${required}`);
+    }
+}
+function commandFor(options) {
+    const flag = options.mode === "task-context" ? `--task-context ${options.taskName ?? ""}` : `--${options.mode}`;
+    return `ty-context export-context ${flag}`;
+}
+function taskSlug(value) {
+    return value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "task";
+}
+function sumLines(records) {
+    return records.reduce((sum, record) => sum + record.lines, 0);
+}
+function sumContextLines(contexts) {
+    return contexts.reduce((sum, context) => sum + context.lines, 0);
+}

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

@@ -0,0 +1,25 @@
+import type { SourcePackArtifactReport, SourcePackOmitted } from "./source-pack-types.js";
+export interface PendingArtifact {
+    kind: string;
+    name: string;
+    relativePath: string;
+    content: string;
+    sourceCount: number;
+    sourceLineCount: number;
+    warningCount: number;
+}
+export declare function buildManifest(params: {
+    projectRoot: string;
+    generatedAt: string;
+    command: string;
+    maxPackFiles: number;
+    artifacts: PendingArtifact[];
+    warnings: string[];
+    omitted: SourcePackOmitted;
+    recommendedUploadSets: Record<string, string[]>;
+}): Promise<string>;
+export declare function artifactReport(artifact: PendingArtifact): SourcePackArtifactReport;
+export declare function writeArtifactSet(projectRoot: string, timestampDir: string, artifacts: PendingArtifact[]): Promise<void>;
+export declare function pruneTimestampedExports(projectRoot: string, keepCount: number): Promise<void>;
+export declare function timestampForFile(now: Date): string;
+export declare function readPackageVersion(): Promise<string>;

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

@@ -0,0 +1,93 @@
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import { promises as fs } from "node:fs";
+import { ensureDir, writeTextIfChanged } from "./fs.js";
+import { repoRelative, sha256 } from "./source-pack-records.js";
+const execFileAsync = promisify(execFile);
+export async function buildManifest(params) {
+    const git = await gitInfo(params.projectRoot);
+    const manifest = {
+        schema_version: "source-pack-v1",
+        generated_at: params.generatedAt,
+        tool: "ty-context export-context",
+        tool_version: await readPackageVersion(),
+        git_sha: git.sha,
+        git_dirty: git.dirty,
+        command: params.command,
+        max_pack_files: params.maxPackFiles,
+        artifacts: params.artifacts.map((artifact) => artifactReport(artifact)),
+        warnings: params.warnings,
+        omitted: params.omitted,
+        recommended_upload_sets: params.recommendedUploadSets
+    };
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+export function artifactReport(artifact) {
+    return {
+        kind: artifact.kind,
+        name: artifact.name,
+        path: artifact.relativePath,
+        sha256: sha256(artifact.content),
+        characters: artifact.content.length,
+        source_count: artifact.sourceCount,
+        source_line_count: artifact.sourceLineCount,
+        warning_count: artifact.warningCount
+    };
+}
+export async function writeArtifactSet(projectRoot, timestampDir, artifacts) {
+    const latestDir = path.join(projectRoot, "tmp", "ty-context", "context-exports", "latest");
+    await writeArtifacts(projectRoot, timestampDir, artifacts);
+    await fs.rm(latestDir, { recursive: true, force: true });
+    await writeArtifacts(projectRoot, latestDir, artifacts);
+}
+export async function pruneTimestampedExports(projectRoot, keepCount) {
+    if (!Number.isInteger(keepCount) || keepCount < 0) {
+        throw new Error("export-context --prune requires a non-negative integer");
+    }
+    const exportsRoot = path.join(projectRoot, "tmp", "ty-context", "context-exports");
+    let entries;
+    try {
+        entries = await fs.readdir(exportsRoot);
+    }
+    catch {
+        return;
+    }
+    const timestampDirs = entries.filter((entry) => /^\d{8}T\d{6}Z$/.test(entry)).sort().reverse();
+    for (const entry of timestampDirs.slice(keepCount)) {
+        await fs.rm(path.join(exportsRoot, entry), { recursive: true, force: true });
+    }
+}
+export function timestampForFile(now) {
+    return now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+async function writeArtifacts(projectRoot, outputDir, artifacts) {
+    for (const artifact of artifacts) {
+        const target = path.join(outputDir, ...artifact.name.split("/"));
+        const relative = repoRelative(projectRoot, target);
+        if (!relative.startsWith("tmp/ty-context/context-exports/")) {
+            throw new Error("Source Pack artifacts must stay under tmp/ty-context/context-exports/**");
+        }
+        await ensureDir(path.dirname(target));
+        await writeTextIfChanged(target, artifact.content);
+    }
+}
+async function gitInfo(projectRoot) {
+    try {
+        const shaResult = await execFileAsync("git", ["-C", projectRoot, "rev-parse", "HEAD"], { encoding: "utf8" });
+        const dirtyResult = await execFileAsync("git", ["-C", projectRoot, "status", "--porcelain"], { encoding: "utf8" });
+        return { sha: shaResult.stdout.trim() || null, dirty: dirtyResult.stdout.trim().length > 0 };
+    }
+    catch {
+        return { sha: null, dirty: false };
+    }
+}
+export async function readPackageVersion() {
+    try {
+        const packageJson = JSON.parse(await fs.readFile(new URL("../../package.json", import.meta.url), "utf8"));
+        return packageJson.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { ContextAreaMapping, ContextArtifact, SourcePackRecord } from "./source-pack-types.js";
+export declare function collectCodeRecords(projectRoot: string, warnings: string[], options?: {
+    include?: string[];
+    exclude?: string[];
+    areas?: ContextAreaMapping[];
+}): Promise<SourcePackRecord[]>;
+export declare function collectContextArtifacts(projectRoot: string, warnings: string[], includePatterns?: string[]): Promise<ContextArtifact[]>;
+export declare function countRedactionWarnings(warnings: string[]): number;
+export declare function countLines(content: string): number;
+export declare function sha256(content: string): string;
+export declare function repoRelative(root: string, file: string): string;

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

@@ -0,0 +1,161 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { listFiles, pathExists, readText } from "./fs.js";
+import { shouldExcludeRelativePath, shouldIncludeCodeFile, toPosix } from "./source-files.js";
+import { classifyCodeFile } from "./source-pack-classify.js";
+import { matchesAny } from "./source-pack-config.js";
+const execFileAsync = promisify(execFile);
+const GIT_LS_MAX_BUFFER = 64 * 1024 * 1024;
+const SENSITIVE_ASSIGNMENT_PATTERN = /^(\s*(?:[-*]\s*)?(?:[`"']?[\w.-]*(?:secret|token|cookie|password|api[_-]?key|credential|bearer|authorization)[\w.-]*[`"']?\s*[:=]\s*))(.+?)\s*$/i;
+export async function collectCodeRecords(projectRoot, warnings, options = {}) {
+    const gitCandidates = await listGitCandidateFiles(projectRoot);
+    const candidates = gitCandidates ?? (await listCandidateFiles(projectRoot));
+    const records = [];
+    for (const file of candidates) {
+        const relative = repoRelative(projectRoot, file);
+        if (!shouldIncludeCodeFile(relative) || matchesAny(relative, options.exclude ?? [])) {
+            continue;
+        }
+        if (options.include && options.include.length > 0 && !matchesAny(relative, options.include)) {
+            continue;
+        }
+        if (!(await isRegularFile(file))) {
+            continue;
+        }
+        const rawContent = await readText(file);
+        const redacted = redactSensitiveAssignments(rawContent);
+        if (redacted.count > 0) {
+            warnings.push(`${relative}: redacted ${redacted.count} sensitive assignment line(s)`);
+        }
+        const content = redacted.content;
+        const classification = classifyCodeFile(relative, content, options.areas ?? []);
+        records.push({
+            relative,
+            language: classification.language,
+            lines: countLines(content),
+            characters: content.length,
+            sha256: sha256(content),
+            summary: classification.summary,
+            content,
+            tags: classification.tags,
+            routes: classification.routes,
+            score: classification.score,
+            bucket: classification.bucket,
+            bundle: "omitted"
+        });
+    }
+    return records.sort((left, right) => left.relative.localeCompare(right.relative));
+}
+export async function collectContextArtifacts(projectRoot, warnings, includePatterns) {
+    const files = new Set();
+    for (const relative of ["AGENTS.md", "README.md", "DESIGN.md", "project_context/global.md", "project_context/architecture.md", "project_context/context.toml"]) {
+        await addIfExists(projectRoot, files, warnings, relative, relative.startsWith("project_context/"));
+    }
+    for (const file of await listFiles(path.join(projectRoot, "project_context"))) {
+        const relative = repoRelative(projectRoot, file);
+        if ((relative.endsWith(".md") || relative.endsWith(".toml")) && !shouldExcludeRelativePath(relative)) {
+            files.add(file);
+        }
+    }
+    const artifacts = [];
+    for (const file of [...files].sort((a, b) => repoRelative(projectRoot, a).localeCompare(repoRelative(projectRoot, b)))) {
+        const relative = repoRelative(projectRoot, file);
+        if (includePatterns && includePatterns.length > 0 && !matchesAny(relative, includePatterns)) {
+            continue;
+        }
+        const rawContent = await readText(file);
+        const redacted = redactSensitiveAssignments(rawContent);
+        if (redacted.count > 0) {
+            warnings.push(`${relative}: redacted ${redacted.count} sensitive assignment line(s)`);
+        }
+        artifacts.push({
+            relative,
+            content: redacted.content,
+            lines: countLines(redacted.content),
+            characters: redacted.content.length
+        });
+    }
+    return artifacts;
+}
+export function countRedactionWarnings(warnings) {
+    return warnings.filter((warning) => /redacted \d+ sensitive assignment line/i.test(warning)).length;
+}
+export function countLines(content) {
+    return content.length === 0 ? 0 : content.split(/\r\n|\r|\n/).length;
+}
+export function sha256(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+export function repoRelative(root, file) {
+    return toPosix(path.relative(root, file));
+}
+async function addIfExists(projectRoot, files, warnings, relative, required) {
+    const target = path.join(projectRoot, ...relative.split("/"));
+    if (await pathExists(target)) {
+        files.add(target);
+    }
+    else if (required) {
+        warnings.push(`${relative}: missing expected source file`);
+    }
+}
+async function listGitCandidateFiles(projectRoot) {
+    try {
+        const result = await execFileAsync("git", ["-C", projectRoot, "ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
+            encoding: "utf8",
+            maxBuffer: GIT_LS_MAX_BUFFER
+        });
+        return result.stdout.split("\0").filter(Boolean).map((relative) => path.join(projectRoot, ...toPosix(relative).split("/")));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function listCandidateFiles(projectRoot) {
+    const files = [];
+    await walkCandidates(projectRoot, projectRoot, files);
+    return files;
+}
+async function walkCandidates(projectRoot, current, files) {
+    let entries;
+    try {
+        entries = await fs.readdir(current, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const fullPath = path.join(current, entry.name);
+        const relative = repoRelative(projectRoot, fullPath);
+        if (entry.isDirectory()) {
+            if (!shouldExcludeRelativePath(relative)) {
+                await walkCandidates(projectRoot, fullPath, files);
+            }
+        }
+        else if (entry.isFile() && !shouldExcludeRelativePath(relative)) {
+            files.push(fullPath);
+        }
+    }
+}
+async function isRegularFile(target) {
+    try {
+        return (await fs.stat(target)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function redactSensitiveAssignments(content) {
+    let count = 0;
+    const lines = content.split(/\r?\n/).map((line) => {
+        const match = SENSITIVE_ASSIGNMENT_PATTERN.exec(line);
+        if (!match) {
+            return line;
+        }
+        count += 1;
+        return `${match[1]}[REDACTED]`;
+    });
+    return { content: lines.join("\n"), count };
+}

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

@@ -0,0 +1,12 @@
+import type { ContextAreaMapping, ContextArtifact, SourcePackOmitted, SourcePackRecord } from "./source-pack-types.js";
+export declare const SOURCE_PACK_EXPORT_HEADER = "Export artifact. Do not reference from project_context/context.toml.";
+export interface RenderMeta {
+    generatedAt: string;
+    outputPath: string;
+    command: string;
+    toolVersion: string;
+}
+export declare function renderFullProjectContextArtifact(contexts: ContextArtifact[], warnings: string[], meta: RenderMeta): string;
+export declare function renderCodeIndexArtifact(records: SourcePackRecord[], areas: ContextAreaMapping[], warnings: string[], meta: RenderMeta): string;
+export declare function renderBundleArtifact(title: string, records: SourcePackRecord[], contexts: ContextArtifact[], omitted: SourcePackOmitted, warnings: string[], meta: RenderMeta, policy: string): string;
+export declare function renderTaskContextArtifact(taskName: string, contexts: ContextArtifact[], records: SourcePackRecord[], verification: string[], omitted: SourcePackOmitted, warnings: string[], meta: RenderMeta): string;