@interf/compiler 0.5.1 → 0.6.3

package/dist/lib/interf-scaffold.js

@@ -1,121 +1,3 @@
-import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
-import { basename, join, relative, sep } from "node:path";
-import { getCompiledWorkflow } from "./workflow-definitions.js";
-import { refreshCompiledArtifacts, saveState, initCompiledState, } from "./state.js";
-import { saveEmptyCompiledInventory } from "./state-io.js";
-import { writeObsidianDefaults } from "./obsidian.js";
-import { assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
-import { refreshCompiledBootstrapGuidance } from "./interf-bootstrap.js";
-import { seedCompiledWorkflowPackage } from "./interf-workflow-package.js";
-import { compiledCompiledPathForDataset } from "./project-paths.js";
-import { syncCompiledRawSnapshot } from "./compiled-raw.js";
-import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "./compiled-schema.js";
-import { findSourceDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
-import { defaultControlPathForCompiled, workflowPackagePathForCompiled } from "./compiled-paths.js";
-const DEFAULT_INTERFIGNORE = [
-    ".claude/",
-    ".codex/",
-    ".agents/",
-    ".cursor/",
-    ".interf/tests/",
-    ".interf/tests/targets/sandboxes/",
-    ".interf/runtime/",
-    ".obsidian/",
-    "",
-].join("\n");
-const UNCOMPILED_COMPILED_PLACEHOLDER = "Not yet compiled. Run `interf compile` to build the compiled dataset.";
-function renderUncompiledCompiledFile(compiledName, relativePath, about) {
-    return [
-        `# ${compiledName} — ${relativePath}`,
-        "",
-        UNCOMPILED_COMPILED_PLACEHOLDER,
-        ...(about ? ["", `About: ${about}`] : []),
-        "",
-    ].join("\n");
-}
-function compiledGitignoreEntries(compiledPath) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    const zoneEntries = (schema?.zones ?? [])
-        .filter((zone) => zone.kind !== "runtime")
-        .map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`);
-    return [
-        ...zoneEntries,
-        ".claude/",
-        ".codex/",
-        ".agents/",
-        ".cursor/",
-        ".interf/tests/",
-        ".interf/tests/targets/sandboxes/",
-        ".interf/runtime/",
-        ".obsidian/",
-    ];
-}
-function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    if (!schema) {
-        throw new Error(`Missing compiled schema at ${workflowPackagePathForCompiled(compiledPath)}.`);
-    }
-    ensureCompiledZoneTargets(compiledPath, schema);
-    for (const zone of schema.zones) {
-        if (!zone.required || zone.kind !== "file" || zone.id === "raw")
-            continue;
-        const targetPath = join(compiledPath, zone.path);
-        if (existsSync(targetPath))
-            continue;
-        writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, zone.path, about));
-    }
-}
-export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath = sourcePath) {
-    assertCompiledName(name, "Compiled");
-    assertCompiledContainer(sourcePath);
-    const compiledPath = compiledCompiledPathForDataset(sourcePath, name);
-    assertWritableTargetDir(compiledPath, "Compiled");
-    mkdirSync(compiledPath, { recursive: true });
-    const savedCompiled = findSourceDatasetConfig(loadSourceFolderConfig(sourcePath), name);
-    const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
-    const resolvedAbout = about ?? savedCompiled?.about;
-    const resolvedDatasetPath = savedCompiled
-        ? resolveSourceDatasetPath(sourcePath, savedCompiled)
-        : datasetPath;
-    saveCompiledInterfConfig(compiledPath, {
-        type: "compiled",
-        name,
-        ...(resolvedAbout ? { about: resolvedAbout } : {}),
-        workflow: selectedWorkflow.id,
-        ...(typeof savedCompiled?.max_attempts === "number"
-            ? { max_attempts: savedCompiled.max_attempts }
-            : {}),
-        ...(typeof savedCompiled?.max_loops === "number"
-            ? { max_loops: savedCompiled.max_loops }
-            : {}),
-        checks: savedCompiled?.checks ?? [],
-        workflow_origin: {
-            selected: selectedWorkflow.id,
-            local_draft: false,
-        },
-        source: {
-            path: "./raw",
-            control_path: defaultControlPathForCompiled(compiledPath),
-            dataset_path: relative(compiledPath, resolvedDatasetPath).split(sep).join("/") || ".",
-        },
-    });
-    mkdirSync(join(compiledPath, "raw"), { recursive: true });
-    syncCompiledRawSnapshot(compiledPath, resolvedDatasetPath);
-    writeFileSync(join(compiledPath, ".interfignore"), DEFAULT_INTERFIGNORE);
-    seedCompiledWorkflowPackage({
-        compiledPath,
-        sourcePath,
-        workflowId: selectedWorkflow.id,
-    });
-    scaffoldCompiledOutputs(compiledPath, name, about);
-    refreshCompiledBootstrapGuidance(compiledPath);
-    writeFileSync(join(compiledPath, ".gitignore"), [...compiledGitignoreEntries(compiledPath), ""].join("\n"));
-    saveState(compiledPath, initCompiledState());
-    saveEmptyCompiledInventory(compiledPath);
-    refreshCompiledArtifacts(compiledPath, { ensureViewSpec: true });
-    writeObsidianDefaults(compiledPath, "compiled");
-    return compiledPath;
-}
-export function defaultCompiledNameForSource(sourcePath) {
-    return basename(sourcePath);
-}
+// Compatibility shim for historical `src/lib/interf-scaffold.ts` imports.
+// Source of truth: `src/packages/project-model/interf-scaffold.ts`.
+export * from "../packages/project-model/interf-scaffold.js";

package/dist/lib/interf-workflow-package.d.ts

@@ -1,20 +1 @@
-import { type WorkflowDefinition } from "./workflow-definitions.js";
-export declare function writeCompiledWorkflowPackage(compiledPath: string, workflow: WorkflowDefinition<string>): void;
-export declare function writeWorkflowPackageToDir(workflowDir: string, workflow: WorkflowDefinition<string>, options?: {
-    overwrite?: boolean;
-}): void;
-export declare function seedCompiledWorkflowPackage(options: {
-    compiledPath: string;
-    sourcePath: string;
-    workflowId: string;
-}): void;
-export declare function createLocalWorkflowPackageFromTemplate(options: {
-    sourcePath: string;
-    baseWorkflowId: string;
-    workflowId: string;
-    label: string;
-    hint: string;
-    summarizeBias: string;
-    structureBias: string;
-    shapeBias: string;
-}): string;
+export * from "../packages/workflow-package/interf-workflow-package.js";

package/dist/lib/interf-workflow-package.js

@@ -1,276 +1 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { copyWorkflowPackageDirectory, isPortableWorkflowPackage, patchWorkflowPackageMetadata, resolveWorkflowPackageSourcePath, workflowDefinitionPath, } from "./local-workflows.js";
-import { getCompiledWorkflow, } from "./workflow-definitions.js";
-import { renderCompiledQuerySkill } from "./agent-shells.js";
-import { CHART_APPROXIMATION_NOTES } from "./chart-guidance.js";
-import { writeCompiledSchemaFile } from "./compiled-schema.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
-function workflowPackagePath(dirPath) {
-    return workflowPackagePathForCompiled(dirPath);
-}
-function mergeWorkflowStagePolicyNotes(stages, baseNotes, nextNotes) {
-    const merged = {};
-    for (const stage of stages) {
-        const combined = Array.from(new Set([
-            ...(baseNotes?.[stage.id] ?? []),
-            ...(nextNotes?.[stage.id] ?? []),
-        ].map((note) => note.trim()).filter((note) => note.length > 0)));
-        if (combined.length > 0) {
-            merged[stage.id] = combined;
-        }
-    }
-    return Object.keys(merged).length > 0 ? merged : undefined;
-}
-function writeWorkflowStarterDocs(dirPath, docs, options) {
-    for (const doc of docs ?? []) {
-        const targetPath = join(dirPath, doc.relativePath);
-        if (!options.overwrite && existsSync(targetPath))
-            continue;
-        mkdirSync(dirname(targetPath), { recursive: true });
-        writeFileSync(targetPath, doc.content);
-    }
-}
-function writeWorkflowPackageJson(rootPath, workflow, options) {
-    const targetPath = join(rootPath, "workflow.json");
-    if (!options.overwrite && existsSync(targetPath))
-        return;
-    writeFileSync(targetPath, `${JSON.stringify({
-        id: workflow.id,
-        type: "compiled",
-        compiler_api: workflow.compilerApi ?? {
-            kind: "compiled",
-            version: 1,
-        },
-        label: workflow.label,
-        hint: workflow.hint,
-        stages: workflow.stages.map((stage) => ({
-            id: stage.id,
-            label: stage.label,
-            description: stage.description,
-            contract_type: stage.contractType,
-            skill_dir: stage.skillDir,
-            reads: stage.reads,
-            writes: stage.writes,
-            ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
-        })),
-        ...(workflow.stagePolicyNotes ? { stage_policy_notes: workflow.stagePolicyNotes } : {}),
-    }, null, 2)}\n`);
-}
-function renderWorkflowReadme(workflow) {
-    const stageLines = workflow.stages
-        .map((stage) => `- \`${stage.id}\` — ${stage.description} (${stage.contractType}; reads: ${stage.reads.join(", ")}; writes: ${stage.writes.join(", ")})`)
-        .join("\n");
-    return [
-        `# ${workflow.label}`,
-        "",
-        workflow.hint,
-        "",
-        "## Package",
-        "",
-        "- `workflow.json` = stage graph, compiler API target, and compile contract mapping",
-        "- `compiled.schema.json` = deterministic compiled-dataset output shape",
-        "- `improve/`, `compile/stages/`, and `use/query/` = human-readable authoring docs",
-        "- Portable workflow packages are standalone: explicit stages, schema, and docs live together in this folder",
-        "- Interf Compiler projects native agent shells from these docs for query use, stage execution, and workflow-improvement loops",
-        "",
-        "## Stages",
-        "",
-        stageLines,
-        "",
-        "Interf Compiler runs the local copy of this package directly from `.interf/workflow/` inside each compiled dataset.",
-        "",
-    ].join("\n");
-}
-function renderDerivedWorkflowReadme(options) {
-    return [
-        `# ${options.label}`,
-        "",
-        options.hint,
-        "",
-        `This workflow package was copied from \`${options.baseWorkflowId}\` and materialized as a standalone package for this dataset job.`,
-        "",
-        "Interf Compiler runs the local copy of this package directly. Keep changes in this folder self-contained instead of relying on runtime inheritance or fallback.",
-        "",
-        "## Emphasis",
-        "",
-        `- summarize: ${options.summarizeBias}`,
-        `- structure: ${options.structureBias}`,
-        `- shape: ${options.shapeBias}`,
-        "",
-    ].join("\n");
-}
-function renderImproveSkill(workflow) {
-    return [
-        "# Workflow Improvement",
-        "",
-        `Workflow: ${workflow.id}`,
-        "",
-        "This file is the editable authoring source for Interf Compiler's generated native workflow-improver shell.",
-        "The improver edits this local package directly.",
-        "",
-        "Default loop:",
-        "1. Read the loop context first.",
-        "2. Review preserved stage shells, runtime logs, and saved test runs from failed attempts.",
-        "3. Edit only the local workflow package for this compiled dataset to create a better workflow variation for this dataset.",
-        "4. Keep `workflow.json`, `compiled.schema.json`, and any changed stage docs aligned.",
-        "",
-        "Guardrails:",
-        "- do not edit truth checks, test specs, or raw dataset files",
-        "- do not hardcode expected answers into workflow docs",
-        "- keep this package standalone; do not add or rely on runtime `extends` or fallback behavior",
-        "- prefer small, defensible workflow changes over random churn",
-        "",
-    ].join("\n");
-}
-function renderStageSkill(workflow, stage) {
-    const notes = workflow.stagePolicyNotes?.[stage.id] ?? [];
-    const stageSpecificNotes = stage.contractType === "compiled-file-evidence"
-        ? [
-            "Each summary must use JSON frontmatter and include `source`, `source_kind`, `evidence_tier`, `truth_mode`, `state`, and a non-empty `abstract`.",
-            "Include a clear abstract block in the body so a human can skim the summary quickly.",
-            "Do not skip the abstract just because the overview section is present.",
-        ]
-        : stage.contractType === "compiled-knowledge-structure"
-            ? [
-                "Treat the knowledge layer as retrieval structure, not final truth.",
-                "Prefer durable entity, claim, and index notes over one giant catch-all file.",
-            ]
-            : stage.contractType === "compiled-query-shape"
-                ? [
-                    "Use the compiled focus plus saved truth-check question text to shape `home.md` and retrieval routes.",
-                    "Rewrite `home.md` into a real entrypoint note. Do not leave the scaffold `Not yet compiled.` placeholder in place.",
-                    ...CHART_APPROXIMATION_NOTES,
-                    "Do not copy expected answers into the compiled dataset.",
-                ]
-                : [];
-    return [
-        `# ${stage.label}`,
-        "",
-        stage.description,
-        "",
-        `Contract type: \`${stage.contractType}\``,
-        "",
-        ...(stageSpecificNotes.length > 0
-            ? [
-                "## Requirements",
-                "",
-                ...stageSpecificNotes.map((note) => `- ${note}`),
-                "",
-            ]
-            : []),
-        ...(notes.length > 0
-            ? [
-                "## Notes",
-                "",
-                ...notes.map((note) => `- ${note}`),
-                "",
-            ]
-            : []),
-    ].join("\n");
-}
-export function writeCompiledWorkflowPackage(compiledPath, workflow) {
-    writeWorkflowPackageToDir(workflowPackagePath(compiledPath), workflow);
-}
-export function writeWorkflowPackageToDir(workflowDir, workflow, options = {}) {
-    const overwrite = options.overwrite ?? true;
-    mkdirSync(join(workflowDir, "improve"), { recursive: true });
-    mkdirSync(join(workflowDir, "use", "query"), { recursive: true });
-    mkdirSync(join(workflowDir, "compile", "stages"), { recursive: true });
-    for (const stage of workflow.stages) {
-        mkdirSync(join(workflowDir, "compile", "stages", stage.skillDir), { recursive: true });
-    }
-    writeWorkflowPackageJson(workflowDir, workflow, { overwrite });
-    if (overwrite || !existsSync(join(workflowDir, "compiled.schema.json"))) {
-        writeCompiledSchemaFile(workflowDir, workflow.stages, `${workflow.label} compiled schema`);
-    }
-    if (overwrite || !existsSync(join(workflowDir, "README.md"))) {
-        writeFileSync(join(workflowDir, "README.md"), renderWorkflowReadme(workflow));
-    }
-    if (overwrite || !existsSync(join(workflowDir, "improve", "SKILL.md"))) {
-        writeFileSync(join(workflowDir, "improve", "SKILL.md"), renderImproveSkill(workflow));
-    }
-    if (overwrite || !existsSync(join(workflowDir, "use", "query", "SKILL.md"))) {
-        writeFileSync(join(workflowDir, "use", "query", "SKILL.md"), renderCompiledQuerySkill());
-    }
-    for (const stage of workflow.stages) {
-        const targetPath = join(workflowDir, "compile", "stages", stage.skillDir, "SKILL.md");
-        if (overwrite || !existsSync(targetPath)) {
-            writeFileSync(targetPath, renderStageSkill(workflow, stage));
-        }
-    }
-    writeWorkflowStarterDocs(workflowDir, workflow.starterDocs, { overwrite });
-}
-export function seedCompiledWorkflowPackage(options) {
-    const resolvedWorkflow = getCompiledWorkflow(options.workflowId, {
-        sourcePath: options.sourcePath,
-    });
-    const sourceWorkflowPath = resolveWorkflowPackageSourcePath(options.sourcePath, resolvedWorkflow.id);
-    if (sourceWorkflowPath && isPortableWorkflowPackage(sourceWorkflowPath)) {
-        // Portable seed packages can be copied directly because compile runs the
-        // local package folder without any source-root fallback.
-        copyWorkflowPackageDirectory(sourceWorkflowPath, workflowPackagePath(options.compiledPath));
-        return;
-    }
-    // Legacy or partially-defined seed packages are resolved once and
-    // materialized into a standalone local package.
-    writeCompiledWorkflowPackage(options.compiledPath, resolvedWorkflow);
-}
-export function createLocalWorkflowPackageFromTemplate(options) {
-    const sourceWorkflowPath = resolveWorkflowPackageSourcePath(options.sourcePath, options.baseWorkflowId);
-    const targetPath = workflowDefinitionPath(options.sourcePath, options.workflowId);
-    const stagePolicyNotes = {
-        summarize: [options.summarizeBias],
-        structure: [options.structureBias],
-        shape: [options.shapeBias],
-    };
-    if (sourceWorkflowPath && isPortableWorkflowPackage(sourceWorkflowPath)) {
-        // Copy directly when the base package is already portable and standalone.
-        copyWorkflowPackageDirectory(sourceWorkflowPath, targetPath);
-        patchWorkflowPackageMetadata(targetPath, {
-            id: options.workflowId,
-            label: options.label,
-            hint: options.hint,
-            stagePolicyNotes,
-        });
-        writeFileSync(join(targetPath, "README.md"), renderDerivedWorkflowReadme({
-            label: options.label,
-            hint: options.hint,
-            baseWorkflowId: options.baseWorkflowId,
-            summarizeBias: options.summarizeBias,
-            structureBias: options.structureBias,
-            shapeBias: options.shapeBias,
-        }));
-        return targetPath;
-    }
-    // Legacy or inherited base packages are materialized immediately so the new
-    // local workflow package is standalone from its first write.
-    const baseWorkflow = getCompiledWorkflow(options.baseWorkflowId, {
-        sourcePath: options.sourcePath,
-    });
-    const localWorkflow = {
-        ...baseWorkflow,
-        id: options.workflowId,
-        label: options.label,
-        hint: options.hint,
-        recommended: false,
-        scope: "local",
-        stagePolicyNotes: mergeWorkflowStagePolicyNotes(baseWorkflow.stages, baseWorkflow.stagePolicyNotes, stagePolicyNotes),
-        starterDocs: [
-            {
-                relativePath: "README.md",
-                content: renderDerivedWorkflowReadme({
-                    label: options.label,
-                    hint: options.hint,
-                    baseWorkflowId: options.baseWorkflowId,
-                    summarizeBias: options.summarizeBias,
-                    structureBias: options.structureBias,
-                    shapeBias: options.shapeBias,
-                }),
-            },
-            ...(baseWorkflow.starterDocs ?? []).filter((doc) => doc.relativePath !== "README.md"),
-        ],
-    };
-    writeWorkflowPackageToDir(targetPath, localWorkflow);
-    return targetPath;
-}
+export * from "../packages/workflow-package/interf-workflow-package.js";

package/dist/lib/interf.d.ts

@@ -1,5 +1 @@
-export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
-export type { InterfConfig, ResolvedCompiled } from "./interf-detect.js";
-export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createCompiled, defaultCompiledNameForSource, } from "./interf-scaffold.js";
+export * from "../packages/project-model/interf.js";

package/dist/lib/interf.js

@@ -1,4 +1,3 @@
-export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
-export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createCompiled, defaultCompiledNameForSource, } from "./interf-scaffold.js";
+// Compatibility shim for historical `src/lib/interf.ts` imports.
+// Source of truth: `src/packages/project-model/interf.ts`.
+export * from "../packages/project-model/interf.js";

package/dist/lib/local-workflows.d.ts

@@ -1,53 +1 @@
-import { z } from "zod";
-import { WorkflowCompilerApiSchema, RuntimeContractTypeSchema, RuntimeStageAcceptanceSchema, WorkflowStageZoneAccessSchema, type WorkflowCompiledSchema } from "./schema.js";
-export interface LocalWorkflowStarterDoc {
-    relativePath: string;
-    content: string;
-}
-export interface LocalWorkflowStageDefinition {
-    id: string;
-    label: string;
-    contract_type: z.infer<typeof RuntimeContractTypeSchema>;
-    skill_dir?: string;
-    description?: string;
-    reads: z.infer<typeof WorkflowStageZoneAccessSchema>;
-    writes: z.infer<typeof WorkflowStageZoneAccessSchema>;
-    acceptance?: z.infer<typeof RuntimeStageAcceptanceSchema>;
-}
-export interface LocalWorkflowDefinition {
-    id: string;
-    type: "compiled";
-    compiler_api?: z.infer<typeof WorkflowCompilerApiSchema>;
-    label: string;
-    hint: string;
-    extends?: string;
-    stages?: LocalWorkflowStageDefinition[];
-    stage_policy_notes?: Record<string, string[]>;
-    compiled_schema: WorkflowCompiledSchema;
-    starter_docs: LocalWorkflowStarterDoc[];
-    directoryPath: string;
-    workflowPath: string;
-    compiledSchemaPath: string;
-}
-export declare function workflowDefinitionPath(sourcePath: string, id: string): string;
-export declare function loadWorkflowDefinitionFromDir(dirPath: string): LocalWorkflowDefinition | null;
-export declare function listLocalWorkflowDefinitions(sourcePath: string): LocalWorkflowDefinition[];
-export declare function loadLocalWorkflowDefinition(sourcePath: string, id: string): LocalWorkflowDefinition | null;
-export declare function resolveWorkflowPackageSourcePath(sourcePath: string, workflowId: string): string | null;
-export declare function isWorkflowId(value: string): boolean;
-export declare function patchWorkflowPackageMetadata(dirPath: string, options?: {
-    id?: string;
-    label?: string;
-    hint?: string;
-    stagePolicyNotes?: Record<string, string[]>;
-}): void;
-export declare function describeWorkflowPackagePortability(dirPath: string): string[];
-export declare function isPortableWorkflowPackage(dirPath: string): boolean;
-export declare function copyWorkflowPackageDirectory(sourceWorkflowPath: string, targetWorkflowPath: string): void;
-export interface WorkflowValidationResult {
-    ok: boolean;
-    summary: string;
-    errors: string[];
-    counts: Record<string, number>;
-}
-export declare function validateWorkflowPackage(dirPath: string): WorkflowValidationResult;
+export * from "../packages/workflow-package/local-workflows.js";