@interf/compiler 0.4.1 → 0.5.1

package/dist/lib/workspace-compile.js

@@ -1,476 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { countFilesRecursive } from "./filesystem.js";
-import { createStageExecutionShell, freezeStageExecutionShell, pruneStageExecutionShells, syncStageExecutionShellWrites, } from "./agent-shells.js";
-import { readInterfConfig, refreshWorkspaceBootstrapGuidance, resolveSourceFolderPath, resolveSourceControlPath, } from "./interf.js";
-import { buildSummarizePlan, writeSummarizePlan } from "./summarize-plan.js";
-import { reconcileWorkspaceShapeRun, reconcileWorkspaceStructureRun, reconcileWorkspaceSummarizeRun, } from "./runtime-reconcile.js";
-import { loadState, refreshWorkspaceArtifacts, } from "./state.js";
-import { buildWorkspaceShapeContract, buildWorkspaceStructureContract, buildWorkspaceSummarizeContract, validateStageContractAcceptance, } from "./runtime.js";
-import { readJsonFileUnchecked } from "./parse.js";
-import { validateWorkflowPackage } from "./local-workflows.js";
-import { formatActiveWorkspaceWorkflowStageStep, getActiveWorkspaceStagePolicyNotes, getActiveWorkspaceWorkflow, resolveWorkspaceWorkflowFromConfig, resolveActiveWorkspaceStageAcceptance, } from "./workflow-definitions.js";
-import { validateWorkspaceCompile, validateWorkspaceStructure, validateWorkspaceSummarize, } from "./validate.js";
-import { buildLocalSkillContractExtension, buildStageInstructions, bundledSkillForContractType, reportBlankLine, reportLine, reportValidationFailure, workflowCompileStageDirectory, } from "./workflow-helpers.js";
-import { executeValidatedStage, executeValidatedSummarizeStage, findStageByContractType, } from "./workflow-stage-runner.js";
-import { syncWorkspaceRawSnapshot } from "./workspace-raw.js";
-import { workspaceRuntimeRoot } from "./workspace-paths.js";
-const SHAPE_INPUT_RELATIVE_PATH = ".interf/runtime/shape-input.json";
-export function resolveWorkspaceContext(workspacePath) {
-    const config = readInterfConfig(workspacePath);
-    const workflowId = resolveWorkspaceWorkflowFromConfig(config);
-    return {
-        workspaceName: config?.name ?? "workspace",
-        sourcePath: resolveSourceFolderPath(workspacePath, config),
-        controlPath: resolveSourceControlPath(workspacePath),
-        workflowId,
-    };
-}
-export function workspaceExecutionStages(workflowId, workspacePath) {
-    return getActiveWorkspaceWorkflow(workspacePath, workflowId)
-        .stages;
-}
-function readWorkspaceInventoryTotal(workspacePath) {
-    const inventory = readJsonFileUnchecked(join(workspaceRuntimeRoot(workspacePath), "inventory.json"), "workspace inventory");
-    if (!inventory)
-        return 0;
-    if (typeof inventory.total === "number")
-        return inventory.total;
-    if (typeof inventory.summary_total === "number")
-        return inventory.summary_total;
-    if (Array.isArray(inventory.entries))
-        return inventory.entries.length;
-    if (Array.isArray(inventory.summaries))
-        return inventory.summaries.length;
-    if (Array.isArray(inventory.files))
-        return inventory.files.length;
-    if (Array.isArray(inventory.items))
-        return inventory.items.length;
-    return 0;
-}
-function isWorkspaceSummarizeStageComplete(workspacePath, expectedSummaryTotal) {
-    const validation = validateWorkspaceSummarize(workspacePath);
-    const acceptance = validateStageContractAcceptance(workspacePath);
-    const state = loadState(workspacePath);
-    const inventoryTotal = readWorkspaceInventoryTotal(workspacePath);
-    return Boolean(validation.ok &&
-        acceptance.ok &&
-        state?.inventory_complete === true &&
-        typeof state.last_summarize === "string" &&
-        state.last_summarize.length > 0 &&
-        (state.summarized ?? 0) >= expectedSummaryTotal &&
-        inventoryTotal >= expectedSummaryTotal);
-}
-function isWorkspaceStructureStageComplete(workspacePath, summaryCount) {
-    const validation = validateWorkspaceStructure(workspacePath);
-    const acceptance = validateStageContractAcceptance(workspacePath);
-    const state = loadState(workspacePath);
-    return Boolean(validation.ok &&
-        acceptance.ok &&
-        state?.inventory_complete === true &&
-        typeof state.last_structure === "string" &&
-        state.last_structure.length > 0 &&
-        (state.structured ?? 0) >= summaryCount);
-}
-function isWorkspaceShapeStageComplete(workspacePath, summaryCount) {
-    const validation = validateWorkspaceCompile(workspacePath);
-    const acceptance = validateStageContractAcceptance(workspacePath);
-    const state = loadState(workspacePath);
-    return Boolean(validation.ok &&
-        acceptance.ok &&
-        state?.inventory_complete === true &&
-        typeof state.last_shape === "string" &&
-        state.last_shape.length > 0 &&
-        (state.shaped ?? state.compiled ?? 0) >= summaryCount &&
-        (state.compiled ?? 0) >= summaryCount);
-}
-function writeWorkspaceShapeInput(workspacePath, workspaceName) {
-    const workspaceConfig = readInterfConfig(workspacePath);
-    const questions = (workspaceConfig?.checks ?? []).map((check, index) => ({
-        id: check.id ?? `check-${index + 1}`,
-        question: check.question,
-    }));
-    mkdirSync(workspaceRuntimeRoot(workspacePath), { recursive: true });
-    writeFileSync(join(workspacePath, SHAPE_INPUT_RELATIVE_PATH), JSON.stringify({
-        kind: "workspace-shape-input",
-        version: 1,
-        generated_at: new Date().toISOString(),
-        target_name: workspaceName,
-        about: workspaceConfig?.about ?? null,
-        question_count: questions.length,
-        questions,
-    }, null, 2) + "\n");
-    return SHAPE_INPUT_RELATIVE_PATH;
-}
-export function buildWorkspaceCompileContract(workspacePath, workflowId, summaryCount, instructions, stageId = "shape", stageSkillDir = "shape", shapeInputPath = SHAPE_INPUT_RELATIVE_PATH) {
-    const config = readInterfConfig(workspacePath);
-    const acceptance = resolveActiveWorkspaceStageAcceptance(workspacePath, workflowId, stageId);
-    const localSkills = buildLocalSkillContractExtension(workspacePath, [workflowCompileStageDirectory(stageSkillDir)], "Use them to refine workspace shaping, navigation, and retrieval routes.");
-    return buildWorkspaceShapeContract({
-        workspaceName: config?.name ?? "workspace",
-        summaryCount,
-        shapeInputPath,
-        workflowNotes: getActiveWorkspaceStagePolicyNotes(workspacePath, workflowId, stageId),
-        localSkillDocs: localSkills.reads,
-        instructions,
-        acceptance,
-    });
-}
-function buildWorkspaceStructureStageContract(workspacePath, workflowId, summaryCount, instructions, stageId = "structure", stageSkillDir = "structure") {
-    const config = readInterfConfig(workspacePath);
-    const acceptance = resolveActiveWorkspaceStageAcceptance(workspacePath, workflowId, stageId);
-    const localSkills = buildLocalSkillContractExtension(workspacePath, [workflowCompileStageDirectory(stageSkillDir)], "Use them to refine workspace structure, taxonomy, ontology, entity extraction, and claim extraction.");
-    return buildWorkspaceStructureContract({
-        workspaceName: config?.name ?? "workspace",
-        summaryCount,
-        workflowNotes: getActiveWorkspaceStagePolicyNotes(workspacePath, workflowId, stageId),
-        localSkillDocs: localSkills.reads,
-        instructions,
-        acceptance,
-    });
-}
-export async function runWorkspaceSummarize(options) {
-    const context = resolveWorkspaceContext(options.workspacePath);
-    const sourcePath = options.sourcePath ?? context.sourcePath;
-    const workflowId = context.workflowId;
-    const stageDefinition = options.stageDefinition ?? findStageByContractType(workspaceExecutionStages(workflowId, options.workspacePath), "workspace-file-evidence");
-    const stageStatusLabel = stageDefinition.label.toLowerCase();
-    const plan = buildSummarizePlan(sourcePath, options.workspacePath, options.fullPass ? "all" : "pending");
-    const expectedSummaryTotal = plan.summaryCount + plan.targetCount;
-    const planPath = writeSummarizePlan(options.workspacePath, plan);
-    const localSkills = buildLocalSkillContractExtension(options.workspacePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine summary structure, evidence grouping, and summarization heuristics.");
-    const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), localSkills);
-    if (options.reportSummary !== false) {
-        reportLine(options.reporter, `${plan.sourceCount} source files, ${plan.summaryCount} summarized, ${plan.targetCount} to summarize`);
-    }
-    if (plan.targetCount === 0) {
-        refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true });
-        const validation = validateWorkspaceSummarize(options.workspacePath);
-        if (options.reportStep !== false) {
-            reportLine(options.reporter, `${formatActiveWorkspaceWorkflowStageStep(options.workspacePath, workflowId, stageDefinition.id)} skipped (no work required)`);
-        }
-        if (!validation.ok) {
-            reportValidationFailure(options.reporter, validation.summary);
-        }
-        return {
-            ok: validation.ok,
-            code: validation.ok ? 0 : 1,
-            skipped: true,
-            plan,
-        };
-    }
-    if (options.reportStep !== false) {
-        reportLine(options.reporter, `${formatActiveWorkspaceWorkflowStageStep(options.workspacePath, workflowId, stageDefinition.id)} (${plan.targetCount} files)`);
-    }
-    const shell = createStageExecutionShell(options.workspacePath, context.workspaceName, workflowId, stageDefinition);
-    let stageResult;
-    try {
-        stageResult = await executeValidatedSummarizeStage({
-            executor: options.executor,
-            workspacePath: options.workspacePath,
-            executionPath: shell.rootPath,
-            targetName: context.workspaceName,
-            workflow: workflowId,
-            workflowSourcePath: options.workspacePath,
-            stageDefinition,
-            instructions,
-            summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${plan.targetCount} source files.`,
-            contract: buildWorkspaceSummarizeContract({
-                workspaceName: context.workspaceName,
-                targetCount: plan.targetCount,
-                expectedSummaryTotal,
-                sourcePath,
-                planPath,
-                workflowNotes: getActiveWorkspaceStagePolicyNotes(options.workspacePath, workflowId, stageDefinition.id),
-                localSkillDocs: localSkills.reads,
-                instructions,
-                acceptance: resolveActiveWorkspaceStageAcceptance(options.workspacePath, workflowId, stageDefinition.id),
-            }),
-            statusLines: [
-                `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${plan.targetCount} files.`,
-                "The CLI owns live file-count progress. Do not emit per-file progress.",
-                "If `.interf/runtime/inventory.json` already exists, overwrite it completely instead of patching prior contents.",
-                "Emit STATUS: batch committed after a completed batch has been merged into summaries/ and inventory.",
-                `Emit DONE: ${stageStatusLabel} complete ${plan.targetCount}/${plan.targetCount} when finished.`,
-            ],
-            reporter: options.reporter,
-            completionCheck: () => isWorkspaceSummarizeStageComplete(options.workspacePath, expectedSummaryTotal),
-            syncWrites: () => syncStageExecutionShellWrites(options.workspacePath, shell.rootPath, stageDefinition),
-            reconcile: () => reconcileWorkspaceSummarizeRun(options.workspacePath, expectedSummaryTotal),
-            refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
-            validate: () => validateWorkspaceSummarize(options.workspacePath),
-            startingSummaryCount: plan.summaryCount,
-            targetCount: plan.targetCount,
-        });
-    }
-    finally {
-        freezeStageExecutionShell(shell.rootPath);
-    }
-    if (!stageResult.ok) {
-        return {
-            ok: false,
-            code: stageResult.code,
-            skipped: false,
-            plan,
-        };
-    }
-    return {
-        ok: true,
-        code: 0,
-        skipped: false,
-        plan,
-    };
-}
-async function runWorkspaceStructure(options) {
-    const workspaceConfig = readInterfConfig(options.workspacePath);
-    const workspaceName = workspaceConfig?.name ?? "workspace";
-    const workflowId = resolveWorkspaceWorkflowFromConfig(workspaceConfig);
-    const sourcePath = options.sourcePath ?? resolveSourceFolderPath(options.workspacePath, workspaceConfig);
-    const stageDefinition = options.stageDefinition ?? findStageByContractType(workspaceExecutionStages(workflowId, options.workspacePath), "workspace-knowledge-structure");
-    const stageStatusLabel = stageDefinition.label.toLowerCase();
-    const summaryCount = countFilesRecursive(join(options.workspacePath, "summaries"));
-    const localSkills = buildLocalSkillContractExtension(options.workspacePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine workspace structure, taxonomy, ontology, entity extraction, and claim extraction.");
-    const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), localSkills);
-    if (options.reportStep !== false) {
-        reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatActiveWorkspaceWorkflowStageStep(options.workspacePath, workflowId, stageDefinition.id)} (building knowledge structure)`);
-    }
-    const shell = createStageExecutionShell(options.workspacePath, workspaceName, workflowId, stageDefinition);
-    try {
-        return await executeValidatedStage({
-            executor: options.executor,
-            workspacePath: options.workspacePath,
-            executionPath: shell.rootPath,
-            targetName: workspaceName,
-            workflow: workflowId,
-            workflowSourcePath: options.workspacePath,
-            stageDefinition,
-            instructions,
-            summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${summaryCount} summary files.`,
-            contract: buildWorkspaceStructureStageContract(options.workspacePath, workflowId, summaryCount, instructions, stageDefinition.id, stageDefinition.skillDir),
-            statusLines: [
-                `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${summaryCount} summary files.`,
-                `Emit STATUS: inventoried summaries ${summaryCount}/${summaryCount} after the inventory pass completes.`,
-                `Emit STATUS: structured knowledge layer after entities, claims, and indexes are updated.`,
-                `Emit DONE: ${stageStatusLabel} complete ${summaryCount}/${summaryCount} when the required outputs are on disk.`,
-            ],
-            reporter: options.reporter,
-            completionCheck: () => isWorkspaceStructureStageComplete(options.workspacePath, summaryCount),
-            syncWrites: () => syncStageExecutionShellWrites(options.workspacePath, shell.rootPath, stageDefinition),
-            reconcile: () => reconcileWorkspaceStructureRun(options.workspacePath),
-            refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
-            validate: () => validateWorkspaceStructure(options.workspacePath),
-        });
-    }
-    finally {
-        freezeStageExecutionShell(shell.rootPath);
-    }
-}
-async function runWorkspaceShape(options) {
-    const workspaceConfig = readInterfConfig(options.workspacePath);
-    const workspaceName = workspaceConfig?.name ?? "workspace";
-    const workflowId = resolveWorkspaceWorkflowFromConfig(workspaceConfig);
-    const sourcePath = options.sourcePath ?? resolveSourceFolderPath(options.workspacePath, workspaceConfig);
-    const stageDefinition = options.stageDefinition ?? findStageByContractType(workspaceExecutionStages(workflowId, options.workspacePath), "workspace-query-shape");
-    const stageStatusLabel = stageDefinition.label.toLowerCase();
-    const summaryCount = countFilesRecursive(join(options.workspacePath, "summaries"));
-    const localSkills = buildLocalSkillContractExtension(options.workspacePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine final workspace shaping, navigation, and retrieval routes.");
-    const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), localSkills);
-    const shapeInputPath = writeWorkspaceShapeInput(options.workspacePath, workspaceName);
-    if (options.reportStep !== false) {
-        reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatActiveWorkspaceWorkflowStageStep(options.workspacePath, workflowId, stageDefinition.id)} (shaping workspace surface)`);
-    }
-    const shell = createStageExecutionShell(options.workspacePath, workspaceName, workflowId, stageDefinition);
-    try {
-        return await executeValidatedStage({
-            executor: options.executor,
-            workspacePath: options.workspacePath,
-            executionPath: shell.rootPath,
-            targetName: workspaceName,
-            workflow: workflowId,
-            workflowSourcePath: options.workspacePath,
-            stageDefinition,
-            instructions,
-            summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${summaryCount} summary files.`,
-            contract: buildWorkspaceCompileContract(options.workspacePath, workflowId, summaryCount, instructions, stageDefinition.id, stageDefinition.skillDir, shapeInputPath),
-            statusLines: [
-                `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${summaryCount} summary files.`,
-                `Emit STATUS: read shaping input after ${shapeInputPath} has been loaded.`,
-                "Emit STATUS: shaped workspace surface after home.md and any focused indexes are updated.",
-                `Emit DONE: ${stageStatusLabel} complete ${summaryCount}/${summaryCount} when the required outputs are on disk.`,
-            ],
-            reporter: options.reporter,
-            completionCheck: () => isWorkspaceShapeStageComplete(options.workspacePath, summaryCount),
-            syncWrites: () => syncStageExecutionShellWrites(options.workspacePath, shell.rootPath, stageDefinition),
-            reconcile: () => reconcileWorkspaceShapeRun(options.workspacePath),
-            refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
-            validate: () => validateWorkspaceCompile(options.workspacePath),
-        });
-    }
-    finally {
-        freezeStageExecutionShell(shell.rootPath);
-    }
-}
-async function runWorkspaceCompileStages(options) {
-    const workspaceConfig = readInterfConfig(options.workspacePath);
-    const workflowId = resolveWorkspaceWorkflowFromConfig(workspaceConfig);
-    const sourcePath = options.sourcePath ?? resolveSourceFolderPath(options.workspacePath, workspaceConfig);
-    const stages = workspaceExecutionStages(workflowId, options.workspacePath).filter((stage) => stage.contractType !== "workspace-file-evidence");
-    let structure = null;
-    let shape = null;
-    for (const stageDefinition of stages) {
-        const result = stageDefinition.contractType === "workspace-knowledge-structure"
-            ? await runWorkspaceStructure({
-                executor: options.executor,
-                workspacePath: options.workspacePath,
-                sourcePath,
-                reporter: options.reporter,
-                reportStep: options.reportStep,
-                stageDefinition,
-            })
-            : await runWorkspaceShape({
-                executor: options.executor,
-                workspacePath: options.workspacePath,
-                sourcePath,
-                reporter: options.reporter,
-                reportStep: options.reportStep,
-                stageDefinition,
-            });
-        if (stageDefinition.contractType === "workspace-knowledge-structure") {
-            structure = result;
-        }
-        else if (stageDefinition.contractType === "workspace-query-shape") {
-            shape = result;
-        }
-        if (!result.ok) {
-            return {
-                ok: false,
-                structure,
-                shape,
-                failedStage: stageDefinition.id,
-            };
-        }
-    }
-    return {
-        ok: true,
-        structure,
-        shape,
-        failedStage: null,
-    };
-}
-export async function runWorkspaceCompile(options) {
-    const preserveMode = options.preserveStageShells ?? "on-failure";
-    if (preserveMode !== "always") {
-        pruneStageExecutionShells(options.workspacePath);
-    }
-    let result = null;
-    try {
-        const compileStages = await runWorkspaceCompileStages(options);
-        if (!compileStages.ok) {
-            result = compileStages.shape ?? compileStages.structure ?? { ok: false, code: 1 };
-            return result;
-        }
-        result = compileStages.shape ?? compileStages.structure ?? { ok: true, code: 0 };
-        return result;
-    }
-    finally {
-        if (preserveMode !== "always" && result?.ok) {
-            pruneStageExecutionShells(options.workspacePath);
-        }
-    }
-}
-export async function compileWorkspace(options) {
-    const preserveMode = options.preserveStageShells ?? "on-failure";
-    if (preserveMode !== "always") {
-        pruneStageExecutionShells(options.workspacePath);
-    }
-    let result = null;
-    try {
-        const controlPath = resolveSourceControlPath(options.workspacePath);
-        syncWorkspaceRawSnapshot(options.workspacePath, controlPath);
-        refreshWorkspaceBootstrapGuidance(options.workspacePath);
-        const workflowValidation = validateWorkflowPackage(join(options.workspacePath, ".interf", "workflow"));
-        if (!workflowValidation.ok) {
-            const summary = workflowValidation.summary;
-            reportValidationFailure(options.reporter, summary, workflowValidation.errors);
-            const failedResult = {
-                ok: false,
-                summarize: {
-                    ok: false,
-                    code: 1,
-                    skipped: true,
-                    plan: buildSummarizePlan(controlPath, options.workspacePath),
-                    summary,
-                },
-                structure: null,
-                shape: null,
-                compile: {
-                    ok: false,
-                    code: 1,
-                    summary,
-                },
-                failedStage: "workflow",
-            };
-            result = failedResult;
-            return failedResult;
-        }
-        const { sourcePath, workflowId } = resolveWorkspaceContext(options.workspacePath);
-        const stages = workspaceExecutionStages(workflowId, options.workspacePath);
-        let summarize = {
-            ok: true,
-            code: 0,
-            skipped: true,
-            plan: buildSummarizePlan(sourcePath, options.workspacePath),
-        };
-        let evidencePassCount = 0;
-        for (const stageDefinition of stages) {
-            if (stageDefinition.contractType !== "workspace-file-evidence") {
-                break;
-            }
-            summarize = await runWorkspaceSummarize({
-                executor: options.executor,
-                workspacePath: options.workspacePath,
-                sourcePath,
-                reporter: options.reporter,
-                reportSummary: evidencePassCount === 0,
-                reportStep: true,
-                stageDefinition,
-                fullPass: evidencePassCount > 0,
-            });
-            evidencePassCount += 1;
-            if (!summarize.ok) {
-                result = {
-                    ok: false,
-                    summarize,
-                    structure: null,
-                    shape: null,
-                    compile: null,
-                    failedStage: stageDefinition.id,
-                };
-                return result;
-            }
-        }
-        const compileStages = await runWorkspaceCompileStages({
-            executor: options.executor,
-            workspacePath: options.workspacePath,
-            sourcePath,
-            reporter: options.reporter,
-            reportStep: true,
-        });
-        result = {
-            ok: compileStages.ok,
-            summarize,
-            structure: compileStages.structure,
-            shape: compileStages.shape,
-            compile: compileStages.shape,
-            failedStage: compileStages.failedStage,
-        };
-        return result;
-    }
-    finally {
-        if (preserveMode !== "always" && result?.ok) {
-            pruneStageExecutionShells(options.workspacePath);
-        }
-    }
-}

package/dist/lib/workspace-home.d.ts

@@ -1,5 +0,0 @@
-export declare const UNCOMPILED_WORKSPACE_HOME_NOTICE = "Not yet compiled. Run `interf compile` to build this compiled workspace.";
-export declare function renderUncompiledWorkspaceHome(workspaceName: string, about?: string): string;
-export declare function workspaceHomeHasCompilePlaceholder(content: string): boolean;
-export declare function readWorkspaceHomeContent(dirPath: string): string | null;
-export declare function workspaceHomeIsShaped(dirPath: string): boolean;

package/dist/lib/workspace-home.js

@@ -1,32 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-export const UNCOMPILED_WORKSPACE_HOME_NOTICE = "Not yet compiled. Run `interf compile` to build this compiled workspace.";
-export function renderUncompiledWorkspaceHome(workspaceName, about) {
-    return [
-        `# ${workspaceName} — Home`,
-        "",
-        UNCOMPILED_WORKSPACE_HOME_NOTICE,
-        ...(about ? ["", `About: ${about}`] : []),
-        "",
-    ].join("\n");
-}
-export function workspaceHomeHasCompilePlaceholder(content) {
-    return content.includes(UNCOMPILED_WORKSPACE_HOME_NOTICE);
-}
-export function readWorkspaceHomeContent(dirPath) {
-    const homePath = join(dirPath, "home.md");
-    if (!existsSync(homePath))
-        return null;
-    try {
-        return readFileSync(homePath, "utf8");
-    }
-    catch {
-        return null;
-    }
-}
-export function workspaceHomeIsShaped(dirPath) {
-    const content = readWorkspaceHomeContent(dirPath);
-    if (content === null)
-        return false;
-    return !workspaceHomeHasCompilePlaceholder(content);
-}

package/dist/lib/workspace-layout.d.ts

@@ -1,2 +0,0 @@
-export declare function normalizeLegacyWorkspaceLayout(workspacePath: string): boolean;
-export declare function workspaceNeedsLegacyLayoutNormalization(workspacePath: string): boolean;

package/dist/lib/workspace-layout.js

@@ -1,60 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, renameSync, } from "node:fs";
-import { dirname, join } from "node:path";
-import { WORKSPACE_CONFIG_FILE, WORKSPACE_INTERF_DIR, WORKSPACE_RUNTIME_DIR, WORKSPACE_TEST_DIR, WORKSPACE_WORKFLOW_DIR, workflowPackagePathForWorkspace, workspaceInterfConfigPath, workspaceInterfRoot, workspaceRuntimeRoot, } from "./workspace-paths.js";
-const LEGACY_WORKSPACE_CONFIG_FILE = "interf.json";
-const LEGACY_WORKFLOW_DIR = "workflow";
-function movePathIfMissing(sourcePath, targetPath) {
-    if (!existsSync(sourcePath)) {
-        return false;
-    }
-    if (existsSync(targetPath)) {
-        return false;
-    }
-    mkdirSync(dirname(targetPath), { recursive: true });
-    renameSync(sourcePath, targetPath);
-    return true;
-}
-export function normalizeLegacyWorkspaceLayout(workspacePath) {
-    const interfRoot = workspaceInterfRoot(workspacePath);
-    const runtimeRoot = workspaceRuntimeRoot(workspacePath);
-    let changed = false;
-    changed = movePathIfMissing(join(workspacePath, LEGACY_WORKSPACE_CONFIG_FILE), workspaceInterfConfigPath(workspacePath)) || changed;
-    changed = movePathIfMissing(join(workspacePath, LEGACY_WORKFLOW_DIR), workflowPackagePathForWorkspace(workspacePath)) || changed;
-    if (!existsSync(interfRoot)) {
-        return changed;
-    }
-    for (const entry of readdirSync(interfRoot)) {
-        if (entry === WORKSPACE_RUNTIME_DIR ||
-            entry === WORKSPACE_TEST_DIR ||
-            entry === WORKSPACE_WORKFLOW_DIR ||
-            entry === WORKSPACE_CONFIG_FILE) {
-            continue;
-        }
-        changed = movePathIfMissing(join(interfRoot, entry), join(runtimeRoot, entry)) || changed;
-    }
-    return changed;
-}
-export function workspaceNeedsLegacyLayoutNormalization(workspacePath) {
-    if (existsSync(join(workspacePath, LEGACY_WORKSPACE_CONFIG_FILE)) &&
-        !existsSync(workspaceInterfConfigPath(workspacePath))) {
-        return true;
-    }
-    if (!existsSync(join(workspacePath, WORKSPACE_INTERF_DIR)))
-        return false;
-    if (existsSync(join(workspacePath, LEGACY_WORKFLOW_DIR)) &&
-        !existsSync(workflowPackagePathForWorkspace(workspacePath))) {
-        return true;
-    }
-    for (const entry of readdirSync(join(workspacePath, WORKSPACE_INTERF_DIR))) {
-        if (entry === WORKSPACE_RUNTIME_DIR ||
-            entry === WORKSPACE_TEST_DIR ||
-            entry === WORKSPACE_WORKFLOW_DIR ||
-            entry === WORKSPACE_CONFIG_FILE) {
-            continue;
-        }
-        if (!existsSync(join(workspaceRuntimeRoot(workspacePath), entry))) {
-            return true;
-        }
-    }
-    return false;
-}

package/dist/lib/workspace-paths.d.ts

@@ -1,41 +0,0 @@
-export declare const WORKSPACE_INTERF_DIR = ".interf";
-export declare const WORKSPACE_CONFIG_FILE = "interf.json";
-export declare const WORKSPACE_WORKFLOW_DIR = "workflow";
-export declare const WORKSPACE_TEST_DIR = "tests";
-export declare const WORKSPACE_TEST_TARGETS_DIR = "targets";
-export declare const WORKSPACE_RUNTIME_DIR = "runtime";
-export declare const WORKSPACE_RUNTIME_STATE_FILE = "state.json";
-export declare const WORKSPACE_RUNTIME_HEALTH_FILE = "health.json";
-export declare const WORKSPACE_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
-export declare const WORKSPACE_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
-export declare const WORKSPACE_RUNTIME_INVENTORY_FILE = "inventory.json";
-export declare const WORKSPACE_RUNTIME_RUN_FILE = "run.json";
-export declare const WORKSPACE_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
-export declare const WORKSPACE_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
-export declare function workspaceRuntimeRoot(workspacePath: string): string;
-export declare function workspaceRuntimeFilePath(workspacePath: string, fileName: string): string;
-export declare function workspaceInterfRoot(workspacePath: string): string;
-export declare function workspaceInterfConfigPath(workspacePath: string): string;
-export declare function workflowPackagePathForWorkspace(workspacePath: string): string;
-export declare function testRootForWorkspace(workspacePath: string): string;
-export declare function testRunsRootForWorkspace(workspacePath: string): string;
-export declare function testTargetsRootForWorkspace(workspacePath: string): string;
-export declare function latestTestComparisonPathForWorkspace(workspacePath: string): string;
-export declare function stageExecutionShellsRoot(workspacePath: string): string;
-export declare function workflowImprovementLoopsRoot(workspacePath: string): string;
-export declare function workflowImprovementRunRoot(workspacePath: string, runId: string): string;
-export declare function workflowImprovementLoopRoot(workspacePath: string, runId: string, loopIndex: number): string;
-export declare function targetTestRunsRootForWorkspace(workspacePath: string): string;
-export declare function targetTestSandboxesRootForWorkspace(workspacePath: string): string;
-export declare function workspaceRuntimeLogsRoot(workspacePath: string): string;
-export declare function workspaceQueryAcceptanceRoot(workspacePath: string): string;
-export declare function workspaceRuntimeStatePath(workspacePath: string): string;
-export declare function workspaceRuntimeHealthPath(workspacePath: string): string;
-export declare function workspaceRuntimeViewSpecPath(workspacePath: string): string;
-export declare function workspaceRawSnapshotMetadataPath(workspacePath: string): string;
-export declare function workspaceRuntimeInventoryPath(workspacePath: string): string;
-export declare function workspaceRuntimeRunPath(workspacePath: string): string;
-export declare function workspaceRuntimeRunHistoryPath(workspacePath: string): string;
-export declare function workspaceRuntimeStageContractPath(workspacePath: string): string;
-export declare function resolveSourceControlPathForWorkspace(workspacePath: string): string;
-export declare function defaultControlPathForWorkspace(workspacePath: string): string;