@interf/compiler 0.18.0 → 0.22.0

package/dist/packages/methods/package/method-definitions.js

@@ -1,214 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { builtinMethodPackagePath, isMethodId, listLocalMethodDefinitions, loadLocalMethodDefinition, loadMethodDefinitionFromDir, mergeStagePolicyNotesForStages, } from "./local-methods.js";
-import { listUserMethodDefinitions, loadUserMethodDefinition, } from "./user-methods.js";
-import { warnInterf } from "../../contracts/utils/logger.js";
-import { methodPackagePathForCompiled } from "../../engine/compile/compiled-paths.js";
-import { asPreparationDataDir, preparationMethodPackagePath } from "../../contracts/lib/preparation-paths.js";
-import { resolveSourceControlPath } from "../../project/interf.js";
-import { deriveMethodInputsFromContextInterface, } from "./context-interface.js";
-const DEFAULT_METHOD_ID = "interf-default";
-let builtinDefaultMethodCache = null;
-function toMethodStages(stages) {
-    return stages.map((stage) => ({
-        id: stage.id,
-        label: stage.label,
-        description: stage.description ?? stage.label,
-        contractType: stage.contract_type,
-        skillDir: stage.skill_dir ?? stage.id,
-        role: stage.role && stage.role.trim().length > 0 ? stage.role : "general",
-        reads: [...stage.reads],
-        writes: [...stage.writes],
-    }));
-}
-export function standaloneMethodDefinitionFromLocalPackage(local) {
-    if (!local.stages || local.stages.length === 0) {
-        throw new Error(`Method package "${local.id}" is missing explicit stages. Compiled-local and portable Method packages must be standalone.`);
-    }
-    const stages = toMethodStages(local.stages);
-    const contextInterface = local.method_schema;
-    const inputs = local.inputs?.length
-        ? [...local.inputs]
-        : deriveMethodInputsFromContextInterface(contextInterface);
-    return {
-        id: local.id,
-        compilerApi: local.compiler_api ?? {
-            kind: "compiled",
-            version: 1,
-        },
-        ...(local.purpose
-            ? {
-                purpose: {
-                    label: local.purpose.label,
-                    taskHint: local.purpose.task_hint,
-                },
-            }
-            : {}),
-        inputs,
-        label: local.label,
-        hint: local.hint,
-        recommended: false,
-        contextInterface,
-        ...(contextInterface ? { schema: contextInterface } : {}),
-        stages,
-        stagePolicyNotes: mergeStagePolicyNotesForStages(stages, undefined, local.stage_policy_notes),
-        starterDocs: [...local.starter_docs],
-        scope: "local",
-    };
-}
-function getBuiltinDefaultMethod() {
-    if (builtinDefaultMethodCache)
-        return builtinDefaultMethodCache;
-    const local = loadMethodDefinitionFromDir(builtinMethodPackagePath(DEFAULT_METHOD_ID));
-    if (!local) {
-        throw new Error(`Missing built-in Interf Method package at builtin-methods/${DEFAULT_METHOD_ID}.`);
-    }
-    const resolved = standaloneMethodDefinitionFromLocalPackage(local);
-    builtinDefaultMethodCache = {
-        ...resolved,
-        id: DEFAULT_METHOD_ID,
-        recommended: true,
-        scope: "builtin",
-    };
-    return builtinDefaultMethodCache;
-}
-function listBuiltinCompiledMethods() {
-    return [getBuiltinDefaultMethod()];
-}
-function resolveCompiledMethodFromLocal(methodId, prepDataDir) {
-    const local = loadLocalMethodDefinition(prepDataDir, methodId);
-    if (!local)
-        return null;
-    const resolved = standaloneMethodDefinitionFromLocalPackage(local);
-    return resolved;
-}
-function resolveCompiledMethodFromUserLibrary(methodId) {
-    const user = loadUserMethodDefinition(methodId);
-    if (!user)
-        return null;
-    const resolved = standaloneMethodDefinitionFromLocalPackage(user);
-    return { ...resolved, scope: "user" };
-}
-export function listCompiledMethodChoices(prepDataDir) {
-    const builtins = listBuiltinCompiledMethods();
-    const methodsById = new Map();
-    for (const method of builtins) {
-        methodsById.set(method.id, method);
-    }
-    for (const definition of listUserMethodDefinitions()) {
-        try {
-            const method = resolveCompiledMethodFromUserLibrary(definition.id);
-            if (method)
-                methodsById.set(method.id, method);
-        }
-        catch (error) {
-            warnInterf(`Warning: skipping user Method "${definition.id}" because it could not be resolved cleanly: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (!prepDataDir)
-        return [...methodsById.values()];
-    for (const definition of listLocalMethodDefinitions(prepDataDir)) {
-        try {
-            const method = resolveCompiledMethodFromLocal(definition.id, prepDataDir);
-            if (method)
-                methodsById.set(method.id, method);
-        }
-        catch (error) {
-            warnInterf(`Warning: skipping local Method "${definition.id}" because it could not be resolved cleanly: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return [...methodsById.values()];
-}
-export function getCompiledMethod(methodId, options = {}) {
-    if (options.prepDataDir) {
-        const local = resolveCompiledMethodFromLocal(methodId, options.prepDataDir);
-        if (local)
-            return local;
-    }
-    const user = resolveCompiledMethodFromUserLibrary(methodId);
-    if (user)
-        return user;
-    const builtin = listBuiltinCompiledMethods().find((candidate) => candidate.id === methodId);
-    if (builtin)
-        return builtin;
-    if (options.prepDataDir) {
-        throw new Error(`No Method "${methodId}" found in this workspace, in your user library, or among bundled Methods. Looked under ${preparationMethodPackagePath(asPreparationDataDir(options.prepDataDir), methodId)} and ~/.interf/methods/${methodId}.`);
-    }
-    throw new Error(`Method "${methodId}" is not built-in and no workspace root was provided to look for a local override.`);
-}
-export function getActiveCompiledMethod(compiledPath) {
-    const methodPath = methodPackagePathForCompiled(compiledPath);
-    if (existsSync(join(methodPath, "method.json"))) {
-        const local = loadMethodDefinitionFromDir(methodPath);
-        if (!local) {
-            throw new Error(`Local Method package at ${methodPath} is missing or invalid. Interf compile runs the local package directly; recreate or reseed this portable context.`);
-        }
-        return standaloneMethodDefinitionFromLocalPackage(local);
-    }
-    throw new Error(`Missing local Method package at ${methodPath}. Interf compile runs the local package directly, so recreate or reseed this portable context under ${resolveSourceControlPath(compiledPath)}.`);
-}
-export function resolveCompiledMethodId(value) {
-    if (typeof value === "string" && isMethodId(value)) {
-        return value;
-    }
-    return null;
-}
-export function resolveCompiledMethodFromConfig(config) {
-    if (!config || typeof config !== "object")
-        return null;
-    const raw = config;
-    return resolveCompiledMethodId(raw.method);
-}
-export function resolveRequiredCompiledMethodFromConfig(config, label = "compiled config") {
-    const methodId = resolveCompiledMethodFromConfig(config);
-    if (!methodId) {
-        throw new Error(`Missing or invalid Method in ${label}.`);
-    }
-    return methodId;
-}
-function resolveMethodDefinitionForStageMetadata(methodId, prepDataDir) {
-    if (prepDataDir &&
-        existsSync(join(methodPackagePathForCompiled(prepDataDir), "method.json"))) {
-        return getActiveCompiledMethod(prepDataDir);
-    }
-    return getCompiledMethod(methodId, { prepDataDir });
-}
-function formatMethodStageStep(method, stage) {
-    const stageIndex = method.stages.findIndex((candidate) => candidate.id === stage);
-    if (stageIndex === -1) {
-        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
-    }
-    const stageDefinition = method.stages[stageIndex];
-    if (!stageDefinition) {
-        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
-    }
-    return `Stage ${stageIndex + 1}/${method.stages.length} - ${stageDefinition.label}`;
-}
-export function getMethodStageDefinition(methodId, stage, prepDataDir) {
-    const method = resolveMethodDefinitionForStageMetadata(methodId, prepDataDir);
-    return method.stages.find((candidate) => candidate.id === stage) ?? null;
-}
-export function getMethodStagePosition(methodId, stage, prepDataDir) {
-    const stages = getMethodStages(methodId, prepDataDir);
-    const stageIndex = stages.findIndex((candidate) => candidate === stage);
-    if (stageIndex === -1)
-        return null;
-    return {
-        stageIndex: stageIndex + 1,
-        stageTotal: stages.length,
-        stages: [...stages],
-    };
-}
-export function getMethodStages(methodId, prepDataDir) {
-    return resolveMethodDefinitionForStageMetadata(methodId, prepDataDir).stages.map((definition) => definition.id);
-}
-export function getActiveCompiledStages(compiledPath) {
-    return getActiveCompiledMethod(compiledPath).stages.map((definition) => definition.id);
-}
-export function getActiveCompiledStagePolicyNotes(compiledPath, stage) {
-    const method = getActiveCompiledMethod(compiledPath);
-    return [...(method.stagePolicyNotes?.[stage] ?? [])];
-}
-export function formatActiveCompiledMethodStageStep(compiledPath, stage) {
-    return formatMethodStageStep(getActiveCompiledMethod(compiledPath), stage);
-}

package/dist/packages/methods/package/method-review-paths.d.ts

@@ -1,10 +0,0 @@
-import type { MethodImprovementContext } from "../../engine/compile/lib/schema.js";
-export interface MethodImprovementReviewSourcePaths {
-    compiledRuntime: string | null;
-    readinessRuns: string | null;
-    executionShells: string | null;
-    targetTestRuns: string | null;
-    targetTestSandboxes: string | null;
-}
-export declare function resolveMethodImprovementReviewSourcePaths(compiledPath: string): MethodImprovementReviewSourcePaths;
-export declare function resolveMethodImprovementReviewPaths(compiledPath: string): MethodImprovementContext["review_paths"];

package/dist/packages/methods/package/method-review-paths.js

@@ -1,31 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "../../engine/compile/compiled-paths.js";
-export function resolveMethodImprovementReviewSourcePaths(compiledPath) {
-    const compiledRuntime = compiledRuntimeRoot(compiledPath);
-    const readinessRuns = testRootForCompiled(compiledPath);
-    const executionShells = stageExecutionShellsRoot(compiledPath);
-    const targetTestRuns = targetTestRunsRootForCompiled(compiledPath);
-    const targetTestSandboxes = targetTestSandboxesRootForCompiled(compiledPath);
-    return {
-        compiledRuntime: existsSync(compiledRuntime) ? compiledRuntime : null,
-        readinessRuns: existsSync(join(readinessRuns, "latest.json")) ||
-            existsSync(join(readinessRuns, "latest.md"))
-            ? readinessRuns
-            : null,
-        executionShells: existsSync(executionShells) ? executionShells : null,
-        targetTestRuns: existsSync(targetTestRuns) ? targetTestRuns : null,
-        targetTestSandboxes: existsSync(targetTestSandboxes) ? targetTestSandboxes : null,
-    };
-}
-export function resolveMethodImprovementReviewPaths(compiledPath) {
-    const sources = resolveMethodImprovementReviewSourcePaths(compiledPath);
-    return {
-        method_root: "method",
-        compiled_runtime: sources.compiledRuntime ? "artifacts/compiled-runtime" : null,
-        readiness_runs: sources.readinessRuns ? "artifacts/readiness-runs" : null,
-        execution_shells: sources.executionShells ? "artifacts/execution-shells" : null,
-        test_runs: sources.targetTestRuns ? "artifacts/test-runs" : null,
-        test_sandboxes: sources.targetTestSandboxes ? "artifacts/test-sandboxes" : null,
-    };
-}

package/dist/packages/methods/package/user-methods.d.ts

@@ -1,17 +0,0 @@
-import { type LocalMethodDefinition } from "./local-methods.js";
-export declare function userMethodPath(id: string): string;
-export declare function userMethodExists(id: string): boolean;
-export declare function listUserMethodDefinitions(): LocalMethodDefinition[];
-export declare function loadUserMethodDefinition(id: string): LocalMethodDefinition | null;
-export interface InstallUserMethodOptions {
-    sourceDir: string;
-    id?: string;
-    overwrite?: boolean;
-}
-export interface InstallUserMethodResult {
-    id: string;
-    path: string;
-    overwritten: boolean;
-}
-export declare function installUserMethod(options: InstallUserMethodOptions): InstallUserMethodResult;
-export declare function removeUserMethod(id: string): boolean;

package/dist/packages/methods/package/user-methods.js

@@ -1,77 +0,0 @@
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { warnInterf } from "../../contracts/utils/logger.js";
-import { userMethodPackagePath, userMethodsRoot, } from "../../contracts/lib/preparation-paths.js";
-import { loadMethodDefinitionFromDir, } from "./local-methods.js";
-export function userMethodPath(id) {
-    return userMethodPackagePath(id);
-}
-export function userMethodExists(id) {
-    return existsSync(join(userMethodPath(id), "method.json"));
-}
-export function listUserMethodDefinitions() {
-    const root = userMethodsRoot();
-    if (!existsSync(root))
-        return [];
-    const definitions = [];
-    for (const entry of readdirSync(root)) {
-        const entryPath = join(root, entry);
-        try {
-            if (!statSync(entryPath).isDirectory())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        const definition = loadMethodDefinitionFromDir(entryPath);
-        if (definition)
-            definitions.push(definition);
-    }
-    return definitions.sort((a, b) => a.label.localeCompare(b.label));
-}
-export function loadUserMethodDefinition(id) {
-    return loadMethodDefinitionFromDir(userMethodPath(id));
-}
-export function installUserMethod(options) {
-    const sourceDir = resolve(options.sourceDir);
-    if (!existsSync(join(sourceDir, "method.json"))) {
-        throw new Error(`No method.json found at ${sourceDir}.`);
-    }
-    const definition = loadMethodDefinitionFromDir(sourceDir);
-    if (!definition) {
-        throw new Error(`Could not load Method package at ${sourceDir}.`);
-    }
-    const id = options.id ?? definition.id;
-    if (!id)
-        throw new Error("Method id is required.");
-    const targetPath = userMethodPath(id);
-    const existed = existsSync(targetPath);
-    if (existed && !options.overwrite) {
-        throw new Error(`User Method "${id}" already exists at ${targetPath}. Pass overwrite to replace it.`);
-    }
-    mkdirSync(dirname(targetPath), { recursive: true });
-    if (existed)
-        rmSync(targetPath, { recursive: true, force: true });
-    cpSync(sourceDir, targetPath, { recursive: true, force: true });
-    if (id !== definition.id) {
-        const targetMethodJson = join(targetPath, "method.json");
-        const raw = readFileSync(targetMethodJson, "utf8");
-        const parsed = JSON.parse(raw);
-        parsed.id = id;
-        writeFileSync(targetMethodJson, `${JSON.stringify(parsed, null, 2)}\n`);
-    }
-    return { id, path: targetPath, overwritten: existed };
-}
-export function removeUserMethod(id) {
-    const target = userMethodPath(id);
-    if (!existsSync(target))
-        return false;
-    try {
-        rmSync(target, { recursive: true, force: true });
-        return true;
-    }
-    catch (error) {
-        warnInterf(`Warning: failed to remove user Method ${id} at ${target}: ${error instanceof Error ? error.message : String(error)}`);
-        return false;
-    }
-}