@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/project/preparation-entries.js

@@ -1,49 +0,0 @@
-import { listVerifiableContextsForSourceFolder, } from "./interf-detect.js";
-import { createVerifiableContext, ensureVerifiableContextScaffold, } from "./interf-scaffold.js";
-import { listSourcePreparationConfigs, loadVerifiableContextPreparationConfig, loadSourceFolderConfig, resolveSourcePreparationPath, sourcePreparationConfigFromInterfConfig, syncVerifiableContextInterfConfigFromSourcePreparationConfig, } from "./source-config.js";
-import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig, } from "../build-plans/build-plan-resolution.js";
-export function listSavedPreparationEntries(prepDataDir) {
-    const builtEntries = new Map();
-    for (const builtContext of listVerifiableContextsForSourceFolder(prepDataDir)) {
-        const preparationConfig = loadVerifiableContextPreparationConfig(builtContext.path)
-            ?? sourcePreparationConfigFromInterfConfig(builtContext.config);
-        builtEntries.set(builtContext.config.name, {
-            config: preparationConfig,
-            path: builtContext.path,
-            localDraft: builtContext.config.build_plan_origin?.local_draft === true,
-        });
-    }
-    const entries = new Map();
-    for (const config of listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir))) {
-        const built = builtEntries.get(config.name);
-        entries.set(config.name, {
-            config,
-            path: built?.path ?? null,
-            localDraft: built?.localDraft ?? false,
-        });
-    }
-    return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
-}
-export function findBuiltVerifiableContextPath(prepDataDir, preparationName) {
-    return listSavedPreparationEntries(prepDataDir).find((entry) => entry.config.name === preparationName)?.path ?? null;
-}
-export function findSavedPreparationConfig(prepDataDir, preparationName) {
-    return listSavedPreparationEntries(prepDataDir).find((entry) => entry.config.name === preparationName)?.config ?? null;
-}
-export function createVerifiableContextFromConfig(prepDataDir, preparationConfig) {
-    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_BUILD_PLAN_ID;
-    const sourceFolderPath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
-    const verifiableContextPath = createVerifiableContext(preparationConfig.name, prepDataDir, buildPlanId, preparationConfig.about, sourceFolderPath);
-    syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath, preparationConfig);
-    return verifiableContextPath;
-}
-export function ensureVerifiableContextFromConfig(prepDataDir, preparationConfig) {
-    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_BUILD_PLAN_ID;
-    const existingPath = findBuiltVerifiableContextPath(prepDataDir, preparationConfig.name);
-    if (existingPath) {
-        ensureVerifiableContextScaffold(prepDataDir, preparationConfig.name, buildPlanId);
-        syncVerifiableContextInterfConfigFromSourcePreparationConfig(existingPath, preparationConfig);
-        return existingPath;
-    }
-    return createVerifiableContextFromConfig(prepDataDir, preparationConfig);
-}

package/dist/packages/project/source-config.d.ts

@@ -1,46 +0,0 @@
-import { type InterfConfig, type SourceFolderBinding, type SourceReadinessCheck, type SourcePreparationConfig, type SourceFolderConfig } from "./lib/schema.js";
-import type { TestSpec, TestTargetType } from "../engine/verify/lib/schema.js";
-export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
-export declare const SOURCE_FOLDER_CONFIG_PATH = "interf.json";
-export interface LoadedSourceTestSpec extends TestSpec {
-    id: string;
-    filePath: string;
-}
-export declare function sourceFolderConfigPath(prepDataDir: string): string;
-export declare function resolveSourceFolderConfigPath(prepDataDir: string): string;
-export declare function fingerprintReadinessChecks(checks: SourceReadinessCheck[]): string;
-export declare function loadSourceFolderConfig(prepDataDir: string): SourceFolderConfig | null;
-export interface WritableSourceProjectConfig {
-    source_folder?: SourceFolderBinding;
-    preparations?: SourcePreparationConfig[];
-}
-export { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig } from "../build-plans/build-plan-resolution.js";
-export declare function listSourcePreparationConfigs(config: SourceFolderConfig | null): SourcePreparationConfig[];
-export declare function resolvePreparationBuildMaxAttempts(preparationConfig: Pick<SourcePreparationConfig, "max_attempts">, override?: number | null): number | null;
-export declare function resolvePreparationBuildMaxLoops(preparationConfig: Pick<SourcePreparationConfig, "max_loops">, override?: number | null): number | null;
-export declare function getDefaultSourcePreparationConfig(config: SourceFolderConfig | null): SourcePreparationConfig | null;
-export declare function findSourcePreparationConfig(config: SourceFolderConfig | null, preparationName: string): SourcePreparationConfig | null;
-export declare function configuredSourceFolderPath(config: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
-export declare function resolveConfiguredSourceFolderPath(prepDataDir: string, config?: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
-export declare function saveSourceFolderConfig(prepDataDir: string, config: WritableSourceProjectConfig): void;
-export declare function appendSourcePreparationChecks(prepDataDir: string, preparationName: string, checks: SourceReadinessCheck[]): void;
-export declare function upsertSourcePreparationConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig, options?: {
-    matchName?: string;
-}): void;
-export declare function removeSourcePreparationConfig(prepDataDir: string, preparationName: string): boolean;
-export declare function buildMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
-export declare function buildMaxLoops(maxLoops: number | null | undefined): number | undefined;
-export declare function sourcePreparationConfigFromInterfConfig(config: InterfConfig, preparationPath?: string): SourcePreparationConfig;
-export declare function loadVerifiableContextPreparationConfig(verifiableContextPath: string): SourcePreparationConfig | null;
-export declare function saveVerifiableContextInterfConfig(verifiableContextPath: string, config: InterfConfig): InterfConfig;
-export declare function syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath: string, preparationConfig: SourcePreparationConfig): InterfConfig;
-export declare function buildTestSpecFromSourceFolderConfig(options: {
-    prepDataDir: string;
-    targetName?: string | null;
-    targetType?: TestTargetType;
-}): LoadedSourceTestSpec | null;
-export declare function buildTestSpecFromPreparationConfig(options: {
-    verifiableContextPath: string;
-    targetType?: TestTargetType;
-}): LoadedSourceTestSpec | null;
-export declare function resolveSourcePreparationPath(prepDataDir: string, preparationConfig: Pick<SourcePreparationConfig, "path">): string;

package/dist/packages/project/source-config.js

@@ -1,394 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import { refreshVerifiableContextBootstrapGuidance } from "../engine/agents/lib/verifiable-context-bootstrap.js";
-import { readInterfConfig, } from "./interf.js";
-import { seedVerifiableContextBuildPlanPackage } from "../build-plans/package/interf-build-plan-package.js";
-import { readJsonFileWithSchema } from "../contracts/utils/parse.js";
-import { getBuildPlan } from "../build-plans/package/build-plan-definitions.js";
-import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig, } from "../build-plans/build-plan-resolution.js";
-import { SourceFolderConfigSchema, } from "./lib/schema.js";
-import { slugify } from "../contracts/utils/naming.js";
-import { assertPathWithinRoot, isPathWithinRoot } from "../contracts/utils/path-guards.js";
-import { defaultControlPathForVerifiableContext, resolveSourceControlPathForVerifiableContext, verifiableContextInterfConfigPath, verifiableContextInterfRoot, } from "../engine/build/verifiable-context-paths.js";
-import { asPreparationDataDir, preparationConfigPath, PREPARATION_CONFIG_FILENAME, } from "../contracts/lib/preparation-paths.js";
-export const SOURCE_FOLDER_CONFIG_FILE = PREPARATION_CONFIG_FILENAME;
-export const SOURCE_FOLDER_CONFIG_PATH = SOURCE_FOLDER_CONFIG_FILE;
-export function sourceFolderConfigPath(prepDataDir) {
-    return preparationConfigPath(asPreparationDataDir(prepDataDir));
-}
-export function resolveSourceFolderConfigPath(prepDataDir) {
-    return sourceFolderConfigPath(prepDataDir);
-}
-function readSourceFolderConfigFile(filePath) {
-    return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
-}
-function normalizeReadinessChecks(cases) {
-    const seen = new Set();
-    return cases.map((caseSpec, index) => {
-        const baseId = slugify(caseSpec.id ?? caseSpec.question) || `check-${index + 1}`;
-        let id = baseId;
-        let suffix = 2;
-        while (seen.has(id)) {
-            id = `${baseId}-${suffix}`;
-            suffix += 1;
-        }
-        seen.add(id);
-        return {
-            id,
-            question: caseSpec.question.trim(),
-            ...(caseSpec.answer ? { answer: caseSpec.answer.trim() } : {}),
-            ...(caseSpec.strictness ? { strictness: caseSpec.strictness.trim() } : {}),
-            ...(caseSpec.expect ? { expect: caseSpec.expect } : {}),
-        };
-    });
-}
-export function fingerprintReadinessChecks(checks) {
-    const normalized = checks.map((check) => ({
-        question: check.question.trim(),
-        ...(check.answer ? { answer: check.answer.trim() } : {}),
-        ...(check.strictness ? { strictness: check.strictness.trim() } : {}),
-        ...(check.expect ? { expect: check.expect } : {}),
-    }));
-    return createHash("sha256")
-        .update(JSON.stringify(normalized))
-        .digest("hex")
-        .slice(0, 16);
-}
-export function loadSourceFolderConfig(prepDataDir) {
-    const filePath = resolveSourceFolderConfigPath(prepDataDir);
-    if (!existsSync(filePath))
-        return null;
-    return readSourceFolderConfigFile(filePath);
-}
-export { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig } from "../build-plans/build-plan-resolution.js";
-function normalizeSourcePreparationConfig(preparationConfig) {
-    const buildPlan = buildPlanIdForSourcePreparationConfig(preparationConfig);
-    return {
-        ...preparationConfig,
-        ...(buildPlan ? { build_plan: buildPlan } : {}),
-    };
-}
-export function listSourcePreparationConfigs(config) {
-    return (config?.preparations ?? []).map((preparation) => normalizeSourcePreparationConfig(preparation));
-}
-export function resolvePreparationBuildMaxAttempts(preparationConfig, override = null) {
-    const configured = override ?? preparationConfig.max_attempts ?? null;
-    if (configured == null)
-        return null;
-    const normalized = Math.trunc(configured);
-    if (!Number.isFinite(normalized) || normalized < 1)
-        return 1;
-    return Math.min(5, normalized);
-}
-export function resolvePreparationBuildMaxLoops(preparationConfig, override = null) {
-    const configured = override ?? preparationConfig.max_loops ?? null;
-    if (configured == null)
-        return null;
-    const normalized = Math.trunc(configured);
-    if (!Number.isFinite(normalized) || normalized < 1)
-        return 1;
-    return Math.min(3, normalized);
-}
-export function getDefaultSourcePreparationConfig(config) {
-    const preparations = listSourcePreparationConfigs(config);
-    return preparations[0] ?? null;
-}
-export function findSourcePreparationConfig(config, preparationName) {
-    return listSourcePreparationConfigs(config).find((preparation) => preparation.name === preparationName) ?? null;
-}
-export function configuredSourceFolderPath(config) {
-    return config?.source_folder?.path ?? null;
-}
-export function resolveConfiguredSourceFolderPath(prepDataDir, config = loadSourceFolderConfig(prepDataDir)) {
-    const configuredPath = configuredSourceFolderPath(config);
-    return configuredPath ? resolve(prepDataDir, configuredPath) : null;
-}
-function toWritableSourceProjectConfig(config) {
-    const preparations = config?.preparations ?? [];
-    const sourceFolder = config?.source_folder;
-    if (preparations.length > 0) {
-        return {
-            ...(sourceFolder ? { source_folder: sourceFolder } : {}),
-            preparations: preparations.map((preparation) => toWritableSourcePreparationConfig(preparation)),
-        };
-    }
-    return {
-        ...(sourceFolder ? { source_folder: sourceFolder } : {}),
-        preparations: [],
-    };
-}
-function toWritableSourcePreparationConfig(preparation) {
-    const buildPlan = buildPlanIdForSourcePreparationConfig(preparation);
-    return {
-        name: preparation.name,
-        path: preparation.path,
-        ...(preparation.about ? { about: preparation.about } : {}),
-        ...(buildPlan ? { build_plan: buildPlan } : {}),
-        ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
-        ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
-        checks: preparation.checks,
-        ...(preparation.requested_artifacts?.length
-            ? { requested_artifacts: preparation.requested_artifacts }
-            : {}),
-        ...(preparation.source_profile ? { source_profile: preparation.source_profile } : {}),
-    };
-}
-export function saveSourceFolderConfig(prepDataDir, config) {
-    const existing = loadSourceFolderConfig(prepDataDir);
-    const mergedConfig = {
-        ...(existing?.source_folder && !config.source_folder ? { source_folder: existing.source_folder } : {}),
-        ...config,
-    };
-    mkdirSync(prepDataDir, { recursive: true });
-    writeFileSync(sourceFolderConfigPath(prepDataDir), JSON.stringify(toWritableSourceProjectConfig(mergedConfig), null, 2) + "\n");
-}
-export function appendSourcePreparationChecks(prepDataDir, preparationName, checks) {
-    const existing = loadSourceFolderConfig(prepDataDir);
-    const currentPreparation = findSourcePreparationConfig(existing, preparationName);
-    const otherPreparations = listSourcePreparationConfigs(existing).filter((preparation) => preparation.name !== preparationName);
-    const currentChecks = currentPreparation?.checks ?? [];
-    const nextPreparation = {
-        ...toWritableSourcePreparationConfig(currentPreparation ?? {
-            name: preparationName,
-            path: `./${preparationName}`,
-            checks: [],
-        }),
-        checks: [...currentChecks, ...checks],
-    };
-    saveSourceFolderConfig(prepDataDir, {
-        preparations: [
-            nextPreparation,
-            ...otherPreparations,
-        ],
-    });
-}
-export function upsertSourcePreparationConfig(prepDataDir, preparationConfig, options = {}) {
-    const existing = loadSourceFolderConfig(prepDataDir);
-    const preparations = listSourcePreparationConfigs(existing);
-    const candidateNames = Array.from(new Set([preparationConfig.name, options.matchName].filter((value) => Boolean(value))));
-    const existingIndex = preparations.findIndex((entry) => candidateNames.includes(entry.name));
-    if (existingIndex >= 0) {
-        preparations[existingIndex] = normalizeSourcePreparationConfig(preparationConfig);
-    }
-    else {
-        preparations.push(normalizeSourcePreparationConfig(preparationConfig));
-    }
-    saveSourceFolderConfig(prepDataDir, {
-        preparations,
-    });
-}
-export function removeSourcePreparationConfig(prepDataDir, preparationName) {
-    const existing = loadSourceFolderConfig(prepDataDir);
-    const preparations = listSourcePreparationConfigs(existing);
-    const nextPreparations = preparations.filter((entry) => entry.name !== preparationName);
-    if (nextPreparations.length === preparations.length)
-        return false;
-    saveSourceFolderConfig(prepDataDir, {
-        preparations: nextPreparations,
-    });
-    return true;
-}
-export function buildMaxAttempts(maxAttempts) {
-    if (maxAttempts == null)
-        return undefined;
-    return resolvePreparationBuildMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
-}
-export function buildMaxLoops(maxLoops) {
-    if (maxLoops == null)
-        return undefined;
-    return resolvePreparationBuildMaxLoops({ max_loops: maxLoops }, null) ?? 1;
-}
-export function sourcePreparationConfigFromInterfConfig(config, preparationPath = `./${config.name}`) {
-    return {
-        name: config.name,
-        path: preparationPath,
-        ...(config.about ? { about: config.about } : {}),
-        build_plan: config.build_plan,
-        ...(typeof config.max_attempts === "number"
-            ? { max_attempts: config.max_attempts }
-            : {}),
-        ...(typeof config.max_loops === "number"
-            ? { max_loops: config.max_loops }
-            : {}),
-        checks: config.checks ?? [],
-    };
-}
-export function loadVerifiableContextPreparationConfig(verifiableContextPath) {
-    const config = readInterfConfig(verifiableContextPath);
-    if (!config)
-        return null;
-    const prepDataDir = resolveSourceControlPathForVerifiableContext(verifiableContextPath);
-    const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
-    const defaultPreparationPath = configuredPreparations.length === 1
-        ? configuredPreparations[0].path
-        : `./${config.name}`;
-    const sourceBinding = typeof config.source?.preparation_path === "string" && config.source.preparation_path.length > 0
-        ? config.source.preparation_path
-        : null;
-    const preparationPath = sourceBinding
-        ? (() => {
-            const sourceAbsolutePath = resolve(verifiableContextPath, sourceBinding);
-            if (!isPathWithinRoot(prepDataDir, sourceAbsolutePath)) {
-                return sourceAbsolutePath;
-            }
-            return relative(prepDataDir, sourceAbsolutePath).split(sep).join("/") || defaultPreparationPath;
-        })()
-        : defaultPreparationPath;
-    return sourcePreparationConfigFromInterfConfig(config, preparationPath);
-}
-export function saveVerifiableContextInterfConfig(verifiableContextPath, config) {
-    mkdirSync(verifiableContextInterfRoot(verifiableContextPath), { recursive: true });
-    writeFileSync(verifiableContextInterfConfigPath(verifiableContextPath), JSON.stringify(config, null, 2) + "\n");
-    return config;
-}
-export function syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath, preparationConfig) {
-    const current = readInterfConfig(verifiableContextPath);
-    const prepDataDir = resolveSourceControlPathForVerifiableContext(verifiableContextPath);
-    const preparationAbsolutePath = resolveConfiguredSourceFolderPath(prepDataDir) ??
-        resolveSourcePreparationPath(prepDataDir, preparationConfig);
-    const preparationRelativePath = relative(verifiableContextPath, preparationAbsolutePath).split(sep).join("/") || ".";
-    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig)
-        ?? buildPlanIdForSourcePreparationConfig(current)
-        ?? DEFAULT_BUILD_PLAN_ID;
-    const buildPlanChanged = current?.build_plan !== undefined && current.build_plan !== buildPlanId;
-    const buildPlanOrigin = buildPlanChanged || !current?.build_plan_origin
-        ? {
-            selected: buildPlanId,
-            local_draft: false,
-        }
-        : current.build_plan_origin;
-    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, build_plan: _ignoredBuildPlan, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, build_plan_origin: _ignoredBuildPlanOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
-    const nextConfig = {
-        ...passthrough,
-        ...(!current ? {
-            type: "verifiable-context",
-            source: {
-                path: preparationRelativePath,
-            },
-        } : {}),
-        type: "verifiable-context",
-        name: preparationConfig.name,
-        ...(preparationConfig.about ? { about: preparationConfig.about } : {}),
-        build_plan: buildPlanId,
-        ...(typeof preparationConfig.max_attempts === "number"
-            ? { max_attempts: preparationConfig.max_attempts }
-            : {}),
-        ...(typeof preparationConfig.max_loops === "number"
-            ? { max_loops: preparationConfig.max_loops }
-            : {}),
-        checks: preparationConfig.checks,
-        build_plan_origin: buildPlanOrigin,
-        source: {
-            path: preparationRelativePath,
-            control_path: defaultControlPathForVerifiableContext(verifiableContextPath),
-            preparation_path: preparationRelativePath,
-        },
-    };
-    const saved = saveVerifiableContextInterfConfig(verifiableContextPath, nextConfig);
-    if (buildPlanChanged) {
-        const selectedBuildPlan = getBuildPlan(buildPlanId, { prepDataDir });
-        seedVerifiableContextBuildPlanPackage({
-            verifiableContextPath,
-            prepDataDir,
-            buildPlanId: selectedBuildPlan.id,
-        });
-    }
-    refreshVerifiableContextBootstrapGuidance(verifiableContextPath);
-    return saved;
-}
-function buildLoadedTestSpec(options) {
-    if (options.checks.length === 0)
-        return null;
-    const testId = options.id ?? slugify(options.name);
-    return {
-        id: options.targetType === "source-files" ? `${testId}-source-files` : `${testId}-verifiable-context`,
-        filePath: options.filePath,
-        type: options.targetType,
-        name: options.name,
-        description: options.about ?? options.defaultDescription,
-        cases: normalizeReadinessChecks(options.checks),
-    };
-}
-export function buildTestSpecFromSourceFolderConfig(options) {
-    const { prepDataDir, targetName, targetType = "verifiable-context" } = options;
-    const config = loadSourceFolderConfig(prepDataDir);
-    if (!config)
-        return null;
-    const preparations = listSourcePreparationConfigs(config);
-    if (preparations.length === 0)
-        return null;
-    const match = targetName
-        ? preparations.find((entry) => entry.name === targetName)
-        : preparations.length === 1
-            ? preparations[0]
-            : getDefaultSourcePreparationConfig(config);
-    if (!match)
-        return null;
-    const configPath = resolveSourceFolderConfigPath(prepDataDir);
-    return buildLoadedTestSpec({
-        id: match.id,
-        name: match.name,
-        about: match.about,
-        checks: match.checks,
-        targetType,
-        filePath: targetType === "source-files"
-            ? `${configPath}#preparations/${match.name}:source-files`
-            : `${configPath}#preparations/${match.name}:verifiable-context`,
-        defaultDescription: `Derived from saved Preparation checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
-    });
-}
-export function buildTestSpecFromPreparationConfig(options) {
-    const { verifiableContextPath, targetType = "verifiable-context" } = options;
-    const config = readInterfConfig(verifiableContextPath);
-    const configPath = verifiableContextInterfConfigPath(verifiableContextPath);
-    if (!config)
-        return null;
-    return buildLoadedTestSpec({
-        name: config.name,
-        about: config.about,
-        checks: config.checks ?? [],
-        targetType,
-        filePath: targetType === "source-files"
-            ? `${configPath}#checks:source-files`
-            : `${configPath}#checks:verifiable-context`,
-        defaultDescription: "Derived from checks in the verifiable-context config.",
-    });
-}
-/**
- * System path prefixes the runtime must never operate on, even when an
- * absolute `preparation.path` was authored by hand. The schema-level
- * refinement in `SourcePreparationConfigSchema` is the primary line of
- * defense; this is the in-process backstop for callers that hand-craft a
- * SourcePreparationConfig at runtime (e.g. Build Plan authoring helpers that
- * construct a config from an InterfConfig).
- */
-const FORBIDDEN_PREPARATION_PATH_PREFIXES = [
-    "/etc",
-    "/sys",
-    "/proc",
-    "/dev",
-    "/var/run",
-    "/var/lib",
-    "/usr",
-    "/bin",
-    "/sbin",
-    "/boot",
-];
-function rejectForbiddenPreparationPath(absolutePath) {
-    for (const prefix of FORBIDDEN_PREPARATION_PATH_PREFIXES) {
-        if (absolutePath === prefix || absolutePath.startsWith(`${prefix}/`)) {
-            throw new Error(`Preparation path may not target system directory ${prefix}: ${absolutePath}`);
-        }
-    }
-}
-export function resolveSourcePreparationPath(prepDataDir, preparationConfig) {
-    const configuredPath = preparationConfig.path.trim();
-    const resolvedPath = resolve(prepDataDir, configuredPath);
-    if (isAbsolute(configuredPath)) {
-        rejectForbiddenPreparationPath(resolvedPath);
-        return resolvedPath;
-    }
-    rejectForbiddenPreparationPath(resolvedPath);
-    return assertPathWithinRoot(prepDataDir, resolvedPath, "Source folder path");
-}

package/dist/packages/project/source-folders.d.ts

@@ -1,11 +0,0 @@
-export declare function listVisibleSourceFolders(prepDataDir: string): string[];
-export declare function isReservedSourcePreparationPath(relativePath: string): boolean;
-export declare function normalizeSourcePreparationPathForConfig(prepDataDir: string, value: string): string;
-export declare function defaultPreparationNameForPath(sourceFolderPath: string): string;
-export declare function findSingleSourceFolderCandidate(prepDataDir: string): string | null;
-export declare function listSourceFolderChoices(prepDataDir?: string): Array<{
-    value: string;
-    label: string;
-    hint: string;
-}>;
-export declare function defaultSourcePreparationPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", prepDataDir?: string): string;

package/public-repo/build-plans/interf-default/build/stages/shape/SKILL.md

@@ -1,27 +0,0 @@
-# Shape
-
-Shape the final verifiable context around the saved task focus and readiness checks.
-
-Contract type: `build-query-shape`
-
-## Requirements
-
-- Use the Build run task focus plus saved readiness-check text to shape `home.md` and retrieval routes.
-- Rewrite `home.md` into a real entrypoint note. Do not leave the scaffold `Not yet built.` placeholder in place.
-- When you add wikilinks, target real verifiable-context notes by exact basename or explicit relative path.
-- If you introduce a new note name in `home.md` or another shaped output, the same stage must also create that note file.
-- Prefer direct file-reading and search tools over shell commands for routine file inspection.
-- When a source value is approximate, preserve it as a bounded range and say why it is approximate.
-- Do not invent finer precision than the source supports.
-- Keep approximate values consistent across `home.md`, focused indexes, and claim/entity notes.
-- Do not copy expected answers into the verifiable context.
-
-## Notes
-
-- Use the saved task focus and readiness checks to bias the final verifiable context toward the job it should be especially good at.
-- Do not copy expected answers into the final verifiable context just because the checks imply them.
-- Prefer the saved summary evidence and structured notes when they already preserve the bounded chart/table reads plus provenance you need.
-- Reopen source references during shaping only when the verifiable context is missing the needed value, the metric family is ambiguous, or the earlier bounded read is clearly inconsistent.
-- If a saved readiness check depends on source-derived values, carry the final bounded values into focused notes with provenance instead of repeatedly recomputing them from source files.
-- Prefer better routing, prioritization, and focused navigation over speculative synthesis.
-- Any wikilinks you add to `home.md` or indexes must resolve to real verifiable-context note basenames or explicit relative paths.

package/public-repo/build-plans/interf-default/build/stages/structure/SKILL.md

@@ -1,21 +0,0 @@
-# Structure
-
-Build the cross-file knowledge structure from the summaries.
-
-Contract type: `build-knowledge-structure`
-
-## Requirements
-
-- Treat the knowledge layer as retrieval structure, not final truth.
-- Prefer durable entity, claim, and index notes over one giant catch-all file.
-- Keep structure-stage links stage-local: prefer linking only to summaries or knowledge notes that are already meaningful by the end of this stage. Avoid relying on `home.md` or other shape-stage routes as the main navigation surface.
-- Prefer direct file-reading and search tools over shell commands for routine file inspection.
-
-## Notes
-
-- Bias structure toward canonical entities, claims, timelines, and stable indexes.
-- Use taxonomy and ontology only as means to improve retrieval, navigation, and evidence tracking.
-- For small source folders, prefer a minimal stable substrate over exhaustive graph sprawl.
-- When you add wikilinks, target real verifiable-context notes by exact basename or explicit relative path. Do not invent title-style links unless that exact title is also a declared note label or alias.
-- Do not add wikilinks in structure outputs to files that the shape stage creates later. If a route belongs in `home.md` or a later shaped note, leave plain text now and let the later stage add the link.
-- For summary references, prefer explicit links like `[[summaries/<file-stem>]]` or plain code paths. For knowledge notes, prefer the final filename stem under `knowledge/`.

package/public-repo/plugins/README.md

@@ -1,9 +0,0 @@
-# Plugins
-
-Host plugin bundles for agent-first Interf use.
-
-This directory is the source of truth for package-shipped plugin assets.
-
-Each plugin should stay thin: a host manifest, the canonical Interf Skill, and
-configuration that starts `interf mcp`. The MCP server itself ships inside
-`interf`.

package/public-repo/plugins/interf/.claude-plugin/plugin.json

@@ -1,21 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
-  "name": "interf",
-  "version": "0.1.0",
-  "description": "Build verifiable context for agents from source files with Interf.",
-  "author": {
-    "name": "Interf Inc.",
-    "url": "https://interf.com"
-  },
-  "homepage": "https://interf.com",
-  "repository": "https://github.com/interf-labs/interf",
-  "license": "SEE LICENSE IN LICENSE.md",
-  "keywords": [
-    "interf",
-    "agents",
-    "data-preparation",
-    "verifiable-context"
-  ],
-  "skills": "./skills/",
-  "mcpServers": "./.mcp.json"
-}

package/public-repo/plugins/interf/.mcp.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "interf": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@interf/compiler@latest",
-        "mcp"
-      ]
-    }
-  }
-}

package/public-repo/plugins/interf/README.md

@@ -1,32 +0,0 @@
-# Interf MCP Integration
-
-This bundle packages Interf for agent hosts that can launch a local MCP server.
-It is not a standalone Interf engine and it should not be treated as a verified
-marketplace plugin format for every host.
-
-Interf builds verifiable context for agents from your files. It turns hidden
-file discovery into traceable artifacts with proof of how they were built.
-
-It contains:
-
-- the same `/interf` Skill available at [`skills/interf`](../../skills/interf/)
-- a local MCP server definition that runs `interf mcp`
-
-The Skill teaches the agent when to use Interf and how to propose requested
-Artifacts. The MCP server gives the host agent tools for Preparations, Build
-Plans, runs, and verifiable context locators.
-
-If the host launches this MCP server on the user's device, the MCP tools can
-call `web_start` to start the local Interf engine and then connect to
-`127.0.0.1:4873`. If the host only runs inside a remote sandbox and does not
-launch a local MCP server, it cannot reach the user's local engine; the user
-must start Interf locally, use a host-provided local connector, or connect to a
-future remote Interf instance.
-
-You can also start the local engine manually with:
-
-```sh
-interf web start
-```
-
-or connect a remote Interf instance before using the MCP tools.