@interf/compiler 0.9.1 → 0.9.3

package/dist/packages/local-service/server.d.ts

@@ -13,5 +13,6 @@ export interface StartedLocalService {
     url: string;
     close(): Promise<void>;
 }
+export declare function resolveCompilerUiStaticRoot(rootPath?: string): string;
 export declare function createLocalServiceServer(runtime: LocalServiceRuntime): Server;
 export declare function startLocalService(options?: StartLocalServiceOptions): Promise<StartedLocalService>;

package/dist/packages/local-service/server.js

@@ -10,19 +10,20 @@ import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_I
 function packageRoot() {
     return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
 }
-function compilerUiAssetBuildRoot() {
-    const explicit = process.env.INTERF_COMPILER_UI_ASSETS?.trim();
+export function resolveCompilerUiStaticRoot(rootPath = packageRoot()) {
+    const distRoot = join(rootPath, "dist", "compiler-ui");
+    const sourceExportRoot = join(rootPath, "apps", "compiler-ui", "out");
+    if (existsSync(join(distRoot, "index.html")))
+        return distRoot;
+    if (existsSync(join(sourceExportRoot, "index.html")))
+        return sourceExportRoot;
+    return distRoot;
+}
+function compilerUiStaticRoot() {
+    const explicit = process.env.INTERF_COMPILER_UI_STATIC_ROOT?.trim();
     if (explicit)
         return resolve(explicit);
-    return join(packageRoot(), "apps", "compiler-ui", ".next");
-}
-function compilerUiPublicRoots() {
-    const explicit = process.env.INTERF_COMPILER_UI_ASSETS?.trim();
-    if (explicit) {
-        const assetRoot = resolve(explicit);
-        return [join(assetRoot, "public"), join(dirname(assetRoot), "public")];
-    }
-    return [join(packageRoot(), "apps", "compiler-ui", "public")];
+    return resolveCompilerUiStaticRoot();
 }
 function localInstancePointerPath(rootPath) {
     return join(rootPath, ...LOCAL_SERVICE_INSTANCE_POINTER_PATH);
@@ -65,6 +66,12 @@ function contentType(filePath) {
             return "image/x-icon";
         case ".txt":
             return "text/plain; charset=utf-8";
+        case ".map":
+            return "application/json; charset=utf-8";
+        case ".webmanifest":
+            return "application/manifest+json; charset=utf-8";
+        case ".woff2":
+            return "font/woff2";
         default:
             return "application/octet-stream";
     }
@@ -170,10 +177,10 @@ function sendFile(res, filePath) {
     }
 }
 function sendCompilerUiAsset(req, res, _runtime) {
-    const buildRoot = compilerUiAssetBuildRoot();
+    const staticRoot = compilerUiStaticRoot();
     const url = parseRequestUrl(req);
     if (url.pathname === "/") {
-        const indexPath = join(buildRoot, "server", "app", "index.html");
+        const indexPath = join(staticRoot, "index.html");
         if (sendFile(res, indexPath))
             return true;
         sendText(res, 503, "Interf UI assets are missing. Run `npm run web:build`, then restart `interf web`.\n");
@@ -181,15 +188,13 @@ function sendCompilerUiAsset(req, res, _runtime) {
     }
     if (url.pathname.startsWith("/_next/static/")) {
         const relativePath = url.pathname.slice("/_next/static/".length);
-        const assetPath = safeStaticPath(join(buildRoot, "static"), relativePath);
-        if (assetPath && sendFile(res, assetPath))
-            return true;
-    }
-    for (const publicRoot of compilerUiPublicRoots()) {
-        const assetPath = safeStaticPath(publicRoot, url.pathname.slice(1));
+        const assetPath = safeStaticPath(join(staticRoot, "_next", "static"), relativePath);
         if (assetPath && sendFile(res, assetPath))
             return true;
     }
+    const assetPath = safeStaticPath(staticRoot, url.pathname.slice(1));
+    if (assetPath && sendFile(res, assetPath))
+        return true;
     return false;
 }
 async function readJsonBody(req) {
@@ -406,7 +411,7 @@ async function routeApi(req, res, runtime) {
     if (method === "POST" &&
         path === LOCAL_SERVICE_ROUTES.methodAuthoringRuns) {
         const body = await readJsonBody(req);
-        const job = await runtime.createWorkflowAuthoringRun(body);
+        const job = await runtime.createMethodAuthoringRun(body);
         sendJson(res, 202, job);
         return true;
     }

package/dist/packages/method-authoring/index.d.ts

@@ -0,0 +1,4 @@
+export * as authoring from "./method-authoring.js";
+export * as editSession from "./method-edit-session.js";
+export * as editUtils from "./lib/method-edit-utils.js";
+export * as improvement from "./method-improvement.js";

package/dist/packages/method-authoring/index.js

@@ -0,0 +1,4 @@
+export * as authoring from "./method-authoring.js";
+export * as editSession from "./method-edit-session.js";
+export * as editUtils from "./lib/method-edit-utils.js";
+export * as improvement from "./method-improvement.js";

package/dist/packages/{workflow-authoring/lib/workflow-edit-utils.d.ts → method-authoring/lib/method-edit-utils.d.ts}

@@ -1,9 +1,9 @@
 export declare function copyDirectory(sourcePath: string, targetPath: string): void;
 export declare function directoriesMatch(leftPath: string, rightPath: string): boolean;
-export interface WorkflowEditShellArtifacts {
+export interface MethodEditShellArtifacts {
     rootPath: string;
-    workflowBeforePath: string;
-    workflowAfterPath: string;
+    methodBeforePath: string;
+    methodAfterPath: string;
     promptLogPath: string;
     eventLogPath: string;
     statusLogPath: string;

package/dist/packages/method-authoring/method-authoring.d.ts

@@ -0,0 +1,24 @@
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import { validateMethodPackage } from "../method-package/local-methods.js";
+import type { SourceReadinessCheck } from "../project-model/lib/schema.js";
+export interface MethodAuthoringRunResult {
+    status: "updated" | "no-change" | "invalid" | "executor-failed";
+    changed: boolean;
+    summary: string;
+    validation: ReturnType<typeof validateMethodPackage> | null;
+    methodPath: string;
+    shellPath: string;
+}
+export declare function runMethodAuthoringDraft(options: {
+    sourcePath: string;
+    sourceFolderPath: string;
+    baseMethodId?: string;
+    methodId: string;
+    label: string;
+    hint: string;
+    taskPrompt: string;
+    checks?: SourceReadinessCheck[];
+    executor: MethodExecutor;
+    onStatus?: (line: string) => void;
+}): Promise<MethodAuthoringRunResult>;
+export declare function resolveMethodDraftPath(sourcePath: string, methodId: string): string;

package/dist/packages/method-authoring/method-authoring.js

@@ -0,0 +1,116 @@
+import { rmSync } from "node:fs";
+import { createMethodAuthoringShell } from "../agents/lib/shells.js";
+import { createScratchLocalMethodPackage } from "../method-package/interf-method-package.js";
+import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
+import { loadMethodDefinitionFromDir, validateMethodPackage, methodDefinitionPath, } from "../method-package/local-methods.js";
+import { runMethodEditSession } from "./method-edit-session.js";
+function buildMethodAuthoringPrompt() {
+    return [
+        "This is an automated Interf Method-authoring run, not an open-ended chat session.",
+        "Execute it now.",
+        "Create one standalone Method package for the source data, desired portable-context outputs, and proof requirements in this source folder.",
+        "Read `runtime/authoring-context.json` first.",
+        "Treat `task_prompt` as the user's preparation-and-evidence brief: source data, output shape, and evidence that should show the data is ready.",
+        `Then read \`method/README.md\`, \`method/method.json\`, and \`method/${CONTEXT_INTERFACE_FILE}\`.`,
+        "The `method/` directory starts as a neutral Method package scaffold, not as a suggested Method.",
+        "Replace the scaffold purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the Method this agent work actually needs.",
+        "Review `artifacts/source-folder/raw/` before editing the package.",
+        "Prefer direct file-reading and search tools over shell commands for routine file inspection.",
+        "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
+        "Edit only files under `method/`.",
+        "Keep the Method package valid for the current compiler API and `method.schema.json`.",
+        "Choose stage ids, stage order, reads, writes, acceptance criteria, and stage docs from the source data and preparation-and-evidence brief.",
+        "Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
+        "Do not preserve the placeholder `prepare` stage unless the final Method genuinely needs a stage with that exact role.",
+        "When editing acceptance criteria: `zone_counts_at_least` maps declared zone ids to fixed numeric minimums.",
+        "`zone_counts_at_least_counts` also maps declared zone ids to runtime count-key strings such as `source_total`; `source_total` is a value, never a zone key.",
+        "For file output zones that replace scaffold files, add `artifacts_must_not_contain` entries that reject `Not yet compiled.` placeholder text; its keys must be artifact paths like `home.md`, not zone ids like `home`.",
+        "Before stopping, verify every zone-count acceptance key is declared in `method.schema.json`.",
+        "For every stage in `method.json`, create `method/compile/stages/<skill_dir>/SKILL.md` and make the folder name exactly match that stage's kebab-case `skill_dir`.",
+        "Every zone path in `method.schema.json` must be unique and non-overlapping. Do not declare both `knowledge/indexes` and `knowledge/indexes/some-file.md` as separate zones.",
+        "Make the package materially specific to this Preparation task, output shape, and proof requirement. A no-op scaffold is not acceptable.",
+        "Treat the Method package as four aligned layers: purpose, inputs, context interface, and stages.",
+        "Keep the portable-context entrypoint canonical: if the Method writes an agent entrypoint, declare zone id `home` with path `home.md` and make the final shaping stage own it.",
+        "Do not move the main entrypoint to `knowledge/home.md` or any other nested path.",
+        "Prefer explicit stage-doc, stage-policy, purpose, input-contract, and context-interface edits over vague rewrites.",
+        "Do not introduce wikilinks unless the Method also creates the target note by exact basename or explicit relative path.",
+        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
+        "Do not make one stage point at files or notes that are only created later by another stage.",
+        "Prefer conservative retrieval routing over speculative note sprawl.",
+        "Do not narrate plans or ask follow-up questions.",
+        "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
+        "As soon as the Method edits are complete, stop.",
+    ].join("\n");
+}
+function validateAuthoredMethodPackage(methodPath) {
+    const validation = validateMethodPackage(methodPath);
+    if (!validation.ok)
+        return validation;
+    const definition = loadMethodDefinitionFromDir(methodPath);
+    if (!definition)
+        return validation;
+    const errors = [...validation.errors];
+    const placeholderStage = definition.stages?.find((stage) => stage.id === "prepare" &&
+        stage.contract_type === "method-draft-stage" &&
+        stage.writes.includes("draft-context"));
+    const placeholderZone = definition.method_schema.zones.find((zone) => zone.id === "draft-context");
+    const placeholderPurpose = definition.purpose?.label === "From-scratch Method draft" ||
+        definition.purpose?.task_hint?.includes("Replace this neutral scaffold");
+    if (placeholderStage) {
+        errors.push("Authored Method still contains the neutral scaffold stage `prepare`.");
+    }
+    if (placeholderZone) {
+        errors.push("Authored Method still contains the neutral scaffold zone `draft-context`.");
+    }
+    if (placeholderPurpose) {
+        errors.push("Authored Method still contains the neutral scaffold purpose.");
+    }
+    return {
+        ok: validation.ok && errors.length === 0,
+        summary: errors.length === 0
+            ? validation.summary
+            : `Method package has ${errors.length} issue(s).`,
+        errors,
+        counts: validation.counts,
+    };
+}
+export async function runMethodAuthoringDraft(options) {
+    const methodPath = createScratchLocalMethodPackage({
+        sourcePath: options.sourcePath,
+        methodId: options.methodId,
+        label: options.label,
+        hint: options.hint,
+    });
+    const shell = createMethodAuthoringShell({
+        methodPath,
+        methodId: options.methodId,
+        label: options.label,
+        referenceMethodId: options.baseMethodId ?? null,
+        sourceFolderPath: options.sourceFolderPath,
+        taskPrompt: options.taskPrompt,
+        checks: options.checks ?? [],
+    });
+    const session = await runMethodEditSession({
+        executor: options.executor,
+        methodPath,
+        shell,
+        prompt: buildMethodAuthoringPrompt(),
+        validate: validateAuthoredMethodPackage,
+        maxValidationRepairAttempts: 1,
+        onStatus: options.onStatus,
+    });
+    if (session.status !== "updated") {
+        rmSync(methodPath, { recursive: true, force: true });
+    }
+    return {
+        status: session.status,
+        changed: session.changed,
+        summary: session.summary,
+        validation: session.validation,
+        methodPath,
+        shellPath: shell.rootPath,
+    };
+}
+export function resolveMethodDraftPath(sourcePath, methodId) {
+    return methodDefinitionPath(sourcePath, methodId);
+}

package/dist/packages/method-authoring/method-edit-session.d.ts

@@ -0,0 +1,18 @@
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import type { MethodValidationResult } from "../method-package/local-methods.js";
+import { type MethodEditShellArtifacts } from "./lib/method-edit-utils.js";
+export interface MethodEditSessionResult {
+    status: "updated" | "no-change" | "invalid" | "executor-failed";
+    changed: boolean;
+    validation: MethodValidationResult | null;
+    summary: string;
+}
+export declare function runMethodEditSession(options: {
+    executor: MethodExecutor;
+    methodPath: string;
+    shell: MethodEditShellArtifacts;
+    prompt: string;
+    validate: (methodPath: string) => MethodValidationResult;
+    maxValidationRepairAttempts?: number;
+    onStatus?: (line: string) => void;
+}): Promise<MethodEditSessionResult>;

package/dist/packages/method-authoring/method-edit-session.js

@@ -0,0 +1,125 @@
+import { appendFileSync, existsSync, realpathSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { copyDirectory, directoriesMatch, } from "./lib/method-edit-utils.js";
+export async function runMethodEditSession(options) {
+    const editableMethodPath = join(options.shell.rootPath, "method");
+    copyDirectory(options.methodPath, options.shell.methodBeforePath);
+    if (!existsSync(editableMethodPath)) {
+        copyDirectory(options.methodPath, editableMethodPath);
+    }
+    writeFileSync(options.shell.promptLogPath, `${options.prompt}\n`);
+    const maxValidationRepairAttempts = options.maxValidationRepairAttempts ?? 0;
+    let prompt = options.prompt;
+    for (let attempt = 0; attempt <= maxValidationRepairAttempts; attempt += 1) {
+        let code = 1;
+        let executeError = null;
+        try {
+            code = await options.executor.execute(options.shell.rootPath, prompt, {
+                eventLogPath: options.shell.eventLogPath,
+                statusLogPath: options.shell.statusLogPath,
+                completionCheck: () => {
+                    try {
+                        if (directoriesMatch(options.shell.methodBeforePath, editableMethodPath))
+                            return false;
+                        return options.validate(editableMethodPath).ok;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onStatus: options.onStatus,
+            });
+        }
+        catch (error) {
+            executeError = error instanceof Error ? error.message : String(error);
+        }
+        copyDirectory(editableMethodPath, options.shell.methodAfterPath);
+        const changed = !directoriesMatch(options.shell.methodBeforePath, options.shell.methodAfterPath);
+        if (executeError) {
+            copyDirectory(options.shell.methodBeforePath, options.methodPath);
+            copyDirectory(options.shell.methodBeforePath, editableMethodPath);
+            return {
+                status: "executor-failed",
+                changed,
+                validation: null,
+                summary: `Method editor failed before completing: ${executeError}`,
+            };
+        }
+        if (code !== 0) {
+            copyDirectory(options.shell.methodBeforePath, options.methodPath);
+            copyDirectory(options.shell.methodBeforePath, editableMethodPath);
+            return {
+                status: "executor-failed",
+                changed,
+                validation: null,
+                summary: `Method editor exited with code ${code}.`,
+            };
+        }
+        const validation = options.validate(editableMethodPath);
+        if (validation.ok) {
+            if (!sameRealPath(editableMethodPath, options.methodPath)) {
+                copyDirectory(editableMethodPath, options.methodPath);
+            }
+            return {
+                status: changed ? "updated" : "no-change",
+                changed,
+                validation,
+                summary: changed
+                    ? "Method package updated and validated."
+                    : "Method package is valid without additional edits.",
+            };
+        }
+        const details = validation.errors.length > 0
+            ? `: ${validation.errors.slice(0, 6).join("; ")}`
+            : "";
+        if (!changed || attempt >= maxValidationRepairAttempts) {
+            copyDirectory(options.shell.methodBeforePath, options.methodPath);
+            copyDirectory(options.shell.methodBeforePath, editableMethodPath);
+            return {
+                status: "invalid",
+                changed,
+                validation,
+                summary: changed
+                    ? `Method package failed validation: ${validation.summary}${details}`
+                    : `Method package is invalid without any Method edits: ${validation.summary}${details}`,
+            };
+        }
+        prompt = [
+            "This is an automated Interf Method validation-repair pass.",
+            "The previous edit did not pass package validation.",
+            "Fix only the validation errors below. Do not redesign the Method.",
+            "",
+            "Validation errors:",
+            ...validation.errors.slice(0, 12).map((error) => `- ${error}`),
+            "",
+            "Rules:",
+            "- Edit only files under `method/`.",
+            "- Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
+            "- Keep every stage `skill_dir` matched by `method/compile/stages/<skill_dir>/SKILL.md`.",
+            "- Keep `method.schema.json` zone paths unique and non-overlapping.",
+            "- Keep zone-count acceptance keys declared in `method.schema.json`.",
+            "- Keep `artifacts_must_not_contain` keys as portable-context relative artifact paths such as `home.md`, not zone ids.",
+            "- Preserve root `home.md` as the main portable-context entrypoint when the Method writes an entrypoint.",
+            "- Stop as soon as the package should validate.",
+        ].join("\n");
+        appendFileSync(options.shell.promptLogPath, `\n\n---\n\n${prompt}\n`);
+    }
+    copyDirectory(options.shell.methodBeforePath, options.methodPath);
+    copyDirectory(options.shell.methodBeforePath, editableMethodPath);
+    return {
+        status: "invalid",
+        changed: true,
+        validation: null,
+        summary: "Method package failed validation.",
+    };
+}
+function sameRealPath(leftPath, rightPath) {
+    try {
+        return existsSync(leftPath) &&
+            existsSync(rightPath) &&
+            realpathSync(leftPath) === realpathSync(rightPath);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/packages/method-authoring/method-improvement.d.ts

@@ -0,0 +1,23 @@
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import { type MethodValidationResult } from "../method-package/local-methods.js";
+import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
+import type { MethodImprovementLoopSummary } from "../compiler/lib/schema.js";
+export interface MethodImprovementRunResult {
+    status: "updated" | "no-change" | "invalid" | "executor-failed";
+    changed: boolean;
+    validation: MethodValidationResult | null;
+    summary: string;
+    shellPath: string;
+    loopRootPath: string;
+}
+export declare function runMethodImprovementLoop(options: {
+    executor: MethodExecutor;
+    compiledPath: string;
+    methodId: string;
+    compiledConfig: Pick<SourcePreparationConfig, "checks">;
+    runId: string;
+    loopIndex: number;
+    maxLoops: number;
+    maxAttempts: number;
+    previousVariations: MethodImprovementLoopSummary[];
+}): Promise<MethodImprovementRunResult>;