@interf/compiler 0.7.3 → 0.9.3

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

@@ -0,0 +1,18 @@
+import { type Server } from "node:http";
+import { type LocalServiceRunHandlers, type LocalServiceRuntime } from "./runtime.js";
+export interface StartLocalServiceOptions {
+    rootPath?: string;
+    host?: string;
+    port?: number;
+    packageVersion?: string;
+    handlers?: Partial<LocalServiceRunHandlers>;
+}
+export interface StartedLocalService {
+    runtime: LocalServiceRuntime;
+    server: Server;
+    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

@@ -0,0 +1,577 @@
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, normalize, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { LocalServiceConfigSchema, LocalServiceDiscoverySchema, LocalServiceInstancePointerSchema, OpenPathRequestSchema, RunCreateRequestSchema, } from "./lib/schema.js";
+import { assertPathWithinRoot, } from "../shared/path-guards.js";
+import { createLocalServiceRuntime, } from "./runtime.js";
+import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_INSTANCE_POINTER_PATH, LOCAL_SERVICE_ROUTES, } from "./routes.js";
+function packageRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+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 resolveCompilerUiStaticRoot();
+}
+function localInstancePointerPath(rootPath) {
+    return join(rootPath, ...LOCAL_SERVICE_INSTANCE_POINTER_PATH);
+}
+function writeLocalInstancePointer(rootPath, pointer) {
+    const pointerPath = localInstancePointerPath(rootPath);
+    mkdirSync(dirname(pointerPath), { recursive: true });
+    const parsed = LocalServiceInstancePointerSchema.parse(pointer);
+    writeFileSync(pointerPath, `${JSON.stringify(parsed, null, 2)}\n`);
+}
+function removeLocalInstancePointer(rootPath, serviceUrl) {
+    const pointerPath = localInstancePointerPath(rootPath);
+    if (!existsSync(pointerPath))
+        return;
+    try {
+        const pointer = LocalServiceInstancePointerSchema.parse(JSON.parse(readFileSync(pointerPath, "utf8")));
+        if (pointer.service_url !== serviceUrl || pointer.pid !== process.pid)
+            return;
+        rmSync(pointerPath, { force: true });
+    }
+    catch {
+        return;
+    }
+}
+function contentType(filePath) {
+    switch (extname(filePath)) {
+        case ".html":
+            return "text/html; charset=utf-8";
+        case ".js":
+            return "text/javascript; charset=utf-8";
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".json":
+            return "application/json; charset=utf-8";
+        case ".svg":
+            return "image/svg+xml";
+        case ".png":
+            return "image/png";
+        case ".ico":
+            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";
+    }
+}
+function writeHeaders(res, statusCode, headers = {}) {
+    res.writeHead(statusCode, {
+        "access-control-allow-origin": "*",
+        "access-control-allow-methods": "GET,POST,PATCH,OPTIONS",
+        "access-control-allow-headers": "content-type",
+        ...headers,
+    });
+}
+function sendJson(res, statusCode, value) {
+    writeHeaders(res, statusCode, {
+        "content-type": "application/json; charset=utf-8",
+    });
+    res.end(`${JSON.stringify(value, null, 2)}\n`);
+}
+function sendText(res, statusCode, value) {
+    writeHeaders(res, statusCode, {
+        "content-type": "text/plain; charset=utf-8",
+    });
+    res.end(value);
+}
+function sendError(res, statusCode, message) {
+    sendJson(res, statusCode, {
+        error: {
+            message,
+        },
+    });
+}
+function resolveOpenPath(allowedRoots, pathValue) {
+    const roots = allowedRoots.map((root) => resolve(root));
+    const targetPath = resolve(pathValue);
+    for (const root of roots) {
+        try {
+            return assertPathWithinRoot(root, targetPath, "Open path");
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`Open path must stay inside ${roots.join(" or ")}: ${targetPath}`);
+}
+async function openLocalPath(allowedRoots, pathValue) {
+    const targetPath = resolveOpenPath(allowedRoots, pathValue);
+    if (!existsSync(targetPath)) {
+        throw new Error(`Path does not exist: ${targetPath}`);
+    }
+    if (process.env.INTERF_OPEN_PATH_DRY_RUN === "1") {
+        return targetPath;
+    }
+    const isDirectory = statSync(targetPath).isDirectory();
+    const command = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "explorer.exe"
+            : "xdg-open";
+    const args = process.platform === "darwin"
+        ? (isDirectory ? [targetPath] : ["-R", targetPath])
+        : process.platform === "win32"
+            ? (isDirectory ? [targetPath] : ["/select,", targetPath])
+            : [isDirectory ? targetPath : dirname(targetPath)];
+    await new Promise((resolveOpen, rejectOpen) => {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.once("error", rejectOpen);
+        child.once("spawn", () => {
+            child.unref();
+            resolveOpen();
+        });
+    });
+    return targetPath;
+}
+function parseRequestUrl(req) {
+    return new URL(req.url ?? "/", "http://127.0.0.1");
+}
+function safeStaticPath(root, relativePath) {
+    const normalized = normalize(relativePath).replace(/^(\.\.(?:\/|\\|$))+/, "");
+    const absolute = resolve(root, normalized);
+    const resolvedRoot = resolve(root);
+    if (absolute !== resolvedRoot && !absolute.startsWith(`${resolvedRoot}${sep}`)) {
+        return null;
+    }
+    return absolute;
+}
+function sendFile(res, filePath) {
+    if (!existsSync(filePath))
+        return false;
+    try {
+        if (!statSync(filePath).isFile())
+            return false;
+        writeHeaders(res, 200, {
+            "content-type": contentType(filePath),
+        });
+        res.end(readFileSync(filePath));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sendCompilerUiAsset(req, res, _runtime) {
+    const staticRoot = compilerUiStaticRoot();
+    const url = parseRequestUrl(req);
+    if (url.pathname === "/") {
+        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");
+        return true;
+    }
+    if (url.pathname.startsWith("/_next/static/")) {
+        const relativePath = url.pathname.slice("/_next/static/".length);
+        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) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw)
+        return {};
+    return JSON.parse(raw);
+}
+async function routeApi(req, res, runtime) {
+    const url = parseRequestUrl(req);
+    const path = url.pathname;
+    const method = req.method ?? "GET";
+    if (method === "OPTIONS") {
+        writeHeaders(res, 204);
+        res.end();
+        return true;
+    }
+    if (method === "GET" && path === "/health") {
+        sendJson(res, 200, runtime.health());
+        return true;
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.api) {
+        sendJson(res, 200, LocalServiceDiscoverySchema.parse({
+            kind: "interf-local-service-discovery",
+            version: 1,
+            resources: {
+                preparations: LOCAL_SERVICE_ROUTES.preparations,
+                methods: LOCAL_SERVICE_ROUTES.methods,
+                runs: LOCAL_SERVICE_ROUTES.runs,
+                readiness: LOCAL_SERVICE_ROUTES.readiness,
+                portable_contexts: LOCAL_SERVICE_ROUTES.portableContexts,
+                source_files: LOCAL_SERVICE_ROUTES.sourceFiles,
+                workspace_files: LOCAL_SERVICE_ROUTES.workspaceFiles,
+                action_proposals: LOCAL_SERVICE_ROUTES.actionProposals,
+                executor: LOCAL_SERVICE_ROUTES.executor,
+            },
+        }));
+        return true;
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.preparations) {
+        sendJson(res, 200, { preparations: runtime.listPreparations() });
+        return true;
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.workspaceFiles) {
+        sendJson(res, 200, { workspace_files: runtime.listWorkspaceFiles() });
+        return true;
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.readiness) {
+        sendJson(res, 200, { readiness: runtime.listPreparationReadiness() });
+        return true;
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.sourceFiles) {
+        const preparation = url.searchParams.get("preparation");
+        sendJson(res, 200, { source_files: runtime.listSourceFiles(preparation) });
+        return true;
+    }
+    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.openPath) {
+        const body = OpenPathRequestSchema.parse(await readJsonBody(req));
+        const health = runtime.health();
+        const allowedRoots = [
+            runtime.rootPath,
+            ...(health.source_folder_path ? [health.source_folder_path] : []),
+        ];
+        const openedPath = await openLocalPath(allowedRoots, body.path);
+        sendJson(res, 202, { opened: true, path: openedPath });
+        return true;
+    }
+    const preparationMatch = path.match(/^\/v1\/preparations\/([^/]+)$/);
+    if (method === "GET" && preparationMatch?.[1]) {
+        const preparation = runtime.getPreparation(decodeURIComponent(preparationMatch[1]));
+        if (!preparation)
+            sendError(res, 404, "Preparation not found.");
+        else
+            sendJson(res, 200, preparation);
+        return true;
+    }
+    const preparationReadinessMatch = path.match(/^\/v1\/preparations\/([^/]+)\/readiness$/);
+    if (method === "GET" && preparationReadinessMatch?.[1]) {
+        const readiness = runtime.getPreparationReadiness(decodeURIComponent(preparationReadinessMatch[1]));
+        if (!readiness)
+            sendError(res, 404, "Preparation not found.");
+        else
+            sendJson(res, 200, readiness);
+        return true;
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.methods) {
+        sendJson(res, 200, { methods: runtime.listMethods() });
+        return true;
+    }
+    const methodMatch = path.match(/^\/v1\/methods\/([^/]+)$/);
+    if (method === "GET" && methodMatch?.[1]) {
+        const methodResource = runtime.getMethod(decodeURIComponent(methodMatch[1]));
+        if (!methodResource)
+            sendError(res, 404, "Method not found.");
+        else
+            sendJson(res, 200, methodResource);
+        return true;
+    }
+    if (method === "GET" && path === "/v1/jobs") {
+        sendJson(res, 200, { jobs: runtime.listJobs() });
+        return true;
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.executor) {
+        sendJson(res, 200, runtime.getExecutorStatus());
+        return true;
+    }
+    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.executor) {
+        const body = await readJsonBody(req);
+        sendJson(res, 202, runtime.selectExecutor(body));
+        return true;
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.actionProposals) {
+        sendJson(res, 200, { action_proposals: runtime.listActionProposals() });
+        return true;
+    }
+    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.actionProposals) {
+        const body = await readJsonBody(req);
+        sendJson(res, 202, await runtime.createActionProposal(body));
+        return true;
+    }
+    const actionProposalMatch = path.match(/^\/v1\/action-proposals\/([^/]+)(?:\/([^/]+))?$/);
+    if (actionProposalMatch?.[1]) {
+        const proposalId = decodeURIComponent(actionProposalMatch[1]);
+        const child = actionProposalMatch[2];
+        if (method === "GET" && !child) {
+            const proposal = runtime.getActionProposal(proposalId);
+            if (!proposal)
+                sendError(res, 404, "Action proposal not found.");
+            else
+                sendJson(res, 200, proposal);
+            return true;
+        }
+        if (method === "POST" && child === "decision") {
+            const body = await readJsonBody(req);
+            const proposal = await runtime.decideActionProposal(proposalId, body);
+            if (!proposal)
+                sendError(res, 404, "Action proposal not found.");
+            else
+                sendJson(res, 202, proposal);
+            return true;
+        }
+    }
+    if (method === "GET" && path === LOCAL_SERVICE_ROUTES.runs) {
+        sendJson(res, 200, { runs: runtime.listRunObservability() });
+        return true;
+    }
+    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.runs) {
+        const request = RunCreateRequestSchema.parse(await readJsonBody(req));
+        if (request.run_type === "compile" || request.run_type === "prepare") {
+            const { run_type: _ignoredRunType, ...compileRequest } = request;
+            const resource = await runtime.createCompileRun(compileRequest);
+            sendJson(res, 202, runtime.getRunObservability(resource.run.run_id) ?? resource);
+            return true;
+        }
+        const { run_type: _ignoredRunType, ...testRequest } = request;
+        const resource = await runtime.createTestRun(testRequest);
+        sendJson(res, 202, runtime.getRunObservability(resource.run_id) ?? resource);
+        return true;
+    }
+    const observableRunMatch = path.match(/^\/v1\/runs\/([^/]+)$/);
+    if (method === "GET" && observableRunMatch?.[1]) {
+        const run = runtime.getRunObservability(decodeURIComponent(observableRunMatch[1]));
+        if (!run)
+            sendError(res, 404, "Run not found.");
+        else
+            sendJson(res, 200, run);
+        return true;
+    }
+    if (method === "POST" && path === "/v1/jobs") {
+        const body = await readJsonBody(req);
+        sendJson(res, 202, runtime.createJobRun(body));
+        return true;
+    }
+    const jobMatch = path.match(/^\/v1\/jobs\/([^/]+)(?:\/([^/]+))?$/);
+    if (jobMatch?.[1]) {
+        const runId = decodeURIComponent(jobMatch[1]);
+        const child = jobMatch[2];
+        if (method === "GET" && !child) {
+            const job = runtime.getJob(runId);
+            if (!job)
+                sendError(res, 404, "Job run not found.");
+            else
+                sendJson(res, 200, job);
+            return true;
+        }
+        if (method === "GET" && child === "events") {
+            const events = runtime.getJobEvents(runId);
+            if (!events)
+                sendError(res, 404, "Job run not found.");
+            else
+                sendJson(res, 200, { events });
+            return true;
+        }
+        if (method === "POST" && child === "events") {
+            const body = await readJsonBody(req);
+            const job = runtime.appendJobRunEvent(runId, body);
+            if (!job)
+                sendError(res, 404, "Job run not found.");
+            else
+                sendJson(res, 202, job);
+            return true;
+        }
+    }
+    if (method === "POST" && path === "/v1/readiness-check-drafts") {
+        const body = await readJsonBody(req);
+        const job = await runtime.createReadinessCheckDraftRun(body);
+        sendJson(res, 202, job);
+        return true;
+    }
+    if (method === "POST" &&
+        path === LOCAL_SERVICE_ROUTES.methodAuthoringRuns) {
+        const body = await readJsonBody(req);
+        const job = await runtime.createMethodAuthoringRun(body);
+        sendJson(res, 202, job);
+        return true;
+    }
+    if (method === "GET" && path === "/v1/compile-runs") {
+        sendJson(res, 200, { compile_runs: runtime.listCompileRuns() });
+        return true;
+    }
+    if (method === "POST" && path === "/v1/compile-runs") {
+        const body = await readJsonBody(req);
+        const resource = await runtime.createCompileRun(body);
+        sendJson(res, 202, resource);
+        return true;
+    }
+    const compileRunMatch = path.match(/^\/v1\/compile-runs\/([^/]+)(?:\/([^/]+))?$/);
+    if (compileRunMatch?.[1]) {
+        const runId = decodeURIComponent(compileRunMatch[1]);
+        const child = compileRunMatch[2];
+        if (method === "GET" && !child) {
+            const run = runtime.getCompileRun(runId);
+            if (!run)
+                sendError(res, 404, "Compile run not found.");
+            else
+                sendJson(res, 200, run);
+            return true;
+        }
+        if (method === "GET" && child === "events") {
+            const events = runtime.getCompileRunEvents(runId);
+            if (!events)
+                sendError(res, 404, "Compile run not found.");
+            else
+                sendJson(res, 200, { events });
+            return true;
+        }
+        if (method === "GET" && child === "proof") {
+            const proof = runtime.getCompileRunProof(runId);
+            if (!proof)
+                sendError(res, 404, "Compile run not found.");
+            else
+                sendJson(res, 200, { proof });
+            return true;
+        }
+        if (method === "GET" && child === "artifacts") {
+            const artifacts = runtime.getCompileRunArtifacts(runId);
+            if (!artifacts)
+                sendError(res, 404, "Compile run not found.");
+            else
+                sendJson(res, 200, { artifacts });
+            return true;
+        }
+        if (method === "POST" && child === "cancel") {
+            sendError(res, 501, "Compile-run cancellation is not implemented yet.");
+            return true;
+        }
+    }
+    if (method === "GET" && path === "/v1/test-runs") {
+        sendJson(res, 200, { test_runs: runtime.listTestRuns() });
+        return true;
+    }
+    if (method === "POST" && path === "/v1/test-runs") {
+        const body = await readJsonBody(req);
+        const resource = await runtime.createTestRun(body);
+        sendJson(res, 202, resource);
+        return true;
+    }
+    const testRunMatch = path.match(/^\/v1\/test-runs\/([^/]+)$/);
+    if (method === "GET" && testRunMatch?.[1]) {
+        const run = runtime.getTestRun(decodeURIComponent(testRunMatch[1]));
+        if (!run)
+            sendError(res, 404, "Readiness check run not found.");
+        else
+            sendJson(res, 200, run);
+        return true;
+    }
+    if (method === "GET" && path === "/v1/portable-contexts") {
+        sendJson(res, 200, { portable_contexts: runtime.listPortableContexts() });
+        return true;
+    }
+    const portableContextMatch = path.match(/^\/v1\/portable-contexts\/([^/]+)$/);
+    if (method === "GET" && portableContextMatch?.[1]) {
+        const context = runtime.getPortableContext(decodeURIComponent(portableContextMatch[1]));
+        if (!context)
+            sendError(res, 404, "Portable context not found.");
+        else
+            sendJson(res, 200, context);
+        return true;
+    }
+    return false;
+}
+export function createLocalServiceServer(runtime) {
+    return createServer((req, res) => {
+        void (async () => {
+            try {
+                const routed = await routeApi(req, res, runtime);
+                if (routed)
+                    return;
+                if (sendCompilerUiAsset(req, res, runtime))
+                    return;
+                sendText(res, 404, "Not found.\n");
+            }
+            catch (error) {
+                sendError(res, 500, error instanceof Error ? error.message : String(error));
+            }
+        })();
+    });
+}
+function resolvePort(optionPort) {
+    if (typeof optionPort === "number")
+        return optionPort;
+    const envPort = Number.parseInt(process.env.INTERF_SERVICE_PORT ?? "", 10);
+    return Number.isInteger(envPort) ? envPort : LOCAL_SERVICE_DEFAULT_PORT;
+}
+export async function startLocalService(options = {}) {
+    const config = LocalServiceConfigSchema.parse({
+        host: options.host ?? process.env.INTERF_SERVICE_HOST ?? LOCAL_SERVICE_DEFAULT_HOST,
+        port: resolvePort(options.port),
+    });
+    const rootPath = options.rootPath ?? process.cwd();
+    const runtime = createLocalServiceRuntime({
+        rootPath,
+        host: config.host,
+        port: config.port,
+        packageVersion: options.packageVersion,
+        handlers: options.handlers,
+    });
+    const server = createLocalServiceServer(runtime);
+    await new Promise((resolveListen, rejectListen) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            rejectListen(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolveListen();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(config.port, config.host);
+    });
+    const url = runtime.health().service_url;
+    writeLocalInstancePointer(rootPath, {
+        service_url: url,
+        host: config.host,
+        port: config.port,
+        pid: process.pid,
+        control_path: resolve(rootPath),
+        started_at: new Date().toISOString(),
+    });
+    return {
+        runtime,
+        server,
+        url,
+        close: () => new Promise((resolveClose, rejectClose) => {
+            server.close((error) => {
+                if (error) {
+                    rejectClose(error);
+                    return;
+                }
+                removeLocalInstancePointer(rootPath, url);
+                resolveClose();
+            });
+        }),
+    };
+}

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;