@interf/compiler 0.9.4 → 0.9.5

package/dist/packages/local-service/action-planner.d.ts

@@ -0,0 +1,9 @@
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import type { LocalServiceActionPlanningContext } from "./runtime.js";
+import { type ActionProposalCreateRequest, type ActionProposalPlan } from "./lib/schema.js";
+export declare function buildActionPlannerPrompt(request: ActionProposalCreateRequest, context: LocalServiceActionPlanningContext, outputPath: string): string;
+export declare function planActionProposalWithExecutor(options: {
+    request: ActionProposalCreateRequest;
+    context: LocalServiceActionPlanningContext;
+    executor: MethodExecutor;
+}): Promise<ActionProposalPlan>;

package/dist/packages/local-service/action-planner.js

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, readFileSync, } from "node:fs";
+import { join } from "node:path";
+import { methodIdForSourcePreparationConfig, } from "../methods/method-resolution.js";
+import { PACKAGE_ROOT } from "../method-package/lib/package-root.js";
+import { ActionProposalPlanSchema, } from "./lib/schema.js";
+function extractJsonObject(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        const match = text.match(/\{[\s\S]*\}/);
+        if (!match)
+            throw new Error("Planner did not write a JSON object.");
+        return JSON.parse(match[0]);
+    }
+}
+function readActionSkill() {
+    const skillDir = join(PACKAGE_ROOT, "agent-skills", "interf-actions");
+    const skillPath = join(skillDir, "SKILL.md");
+    const cliReferencePath = join(skillDir, "references", "cli.md");
+    try {
+        const skill = readFileSync(skillPath, "utf8");
+        const cliReference = readFileSync(cliReferencePath, "utf8");
+        return [
+            skill,
+            "## Bundled reference: references/cli.md",
+            cliReference,
+        ].join("\n\n");
+    }
+    catch {
+        return [
+            "# Interf Actions",
+            "Use `interf --help`, `interf list`, `interf status`, and command-specific help as the source of truth.",
+            "In Interf proposal mode, do not run CLI commands. Write the requested JSON proposal only.",
+        ].join("\n\n");
+    }
+}
+export function buildActionPlannerPrompt(request, context, outputPath) {
+    const actionSkill = readActionSkill();
+    const preparations = context.preparations.map((preparation) => ({
+        name: preparation.name,
+        path: preparation.path,
+        about: preparation.about ?? null,
+        method: methodIdForSourcePreparationConfig(preparation),
+        checks: preparation.checks?.length ?? 0,
+    }));
+    const recentProposals = context.recentProposals.map((proposal) => ({
+        status: proposal.status,
+        action_type: proposal.action_type,
+        title: proposal.title,
+        preparation: proposal.preparation ?? null,
+        request: proposal.request,
+        command_preview: proposal.command_preview ?? null,
+    }));
+    const sourceFolders = context.sourceFolders.map((folder) => ({
+        path: folder.value,
+        label: folder.label,
+        hint: folder.hint,
+    }));
+    return `You are the local Interf action planner.
+
+User request:
+${request.message}
+
+Selected Preparation hint: ${request.preparation ?? "(none)"}
+
+Structured request values:
+${JSON.stringify(request.values ?? {}, null, 2)}
+
+Available Preparations:
+${JSON.stringify(preparations, null, 2)}
+
+Visible Source Folders:
+${JSON.stringify(sourceFolders, null, 2)}
+
+Action health:
+${JSON.stringify(context.preparationHealth, null, 2)}
+
+Recent proposals, newest first. A short follow-up like "target source only" may be correcting the latest pending proposal:
+${JSON.stringify(recentProposals, null, 2)}
+
+Interf action skill source:
+${actionSkill}
+
+Use the Interf action skill source as the authority for CLI semantics and Interf proposal mode. Preserve user intent over defaults.
+Use Action health to avoid proposing work that cannot run yet. If can_check_readiness is false, prefer the recommended next actions; do not propose a generic readiness check unless the user explicitly asks for a source-files-only baseline.
+If the user is asking a question or making casual conversation, return "clarification" with a helpful assistant_message. Do not invent a CLI command for non-action chat.
+If a field does not apply, omit it instead of writing null or an empty string.
+Do not run any CLI command. Do not edit files except the output JSON file.
+
+Write only this JSON object to:
+${outputPath}
+
+JSON schema:
+{
+  "action_type": "preparation-setup" | "preparation-change" | "compile" | "test" | "readiness-check-draft" | "method-authoring" | "method-change" | "method-improvement" | "clarification",
+  "preparation": "Preparation id if applicable",
+  "method": "Method id if applicable",
+  "values": {},
+  "title": "short approval card title",
+  "summary": "one sentence describing what will run",
+  "assistant_message": "concise explanation for the user",
+  "command_preview": "interf command the user is approving"
+}
+`;
+}
+export async function planActionProposalWithExecutor(options) {
+    const planRoot = join(options.context.sourcePath, "interf", ".service", "action-plans", Date.now().toString(36));
+    mkdirSync(planRoot, { recursive: true });
+    const outputPath = join(planRoot, "proposal.json");
+    const prompt = buildActionPlannerPrompt(options.request, options.context, outputPath);
+    const exitCode = await options.executor.execute(options.context.sourcePath, prompt, {
+        eventLogPath: join(planRoot, "planner.events.ndjson"),
+        statusLogPath: join(planRoot, "planner.status.log"),
+        completionCheck: () => existsSync(outputPath),
+    });
+    if (exitCode !== 0 && !existsSync(outputPath)) {
+        return ActionProposalPlanSchema.parse({
+            action_type: "clarification",
+            preparation: options.request.preparation,
+            assistant_message: `${options.executor.displayName} could not create a safe Interf proposal.`,
+        });
+    }
+    try {
+        return ActionProposalPlanSchema.parse(extractJsonObject(readFileSync(outputPath, "utf8")));
+    }
+    catch {
+        return ActionProposalPlanSchema.parse({
+            action_type: "clarification",
+            preparation: options.request.preparation,
+            assistant_message: "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.",
+        });
+    }
+}

package/dist/packages/local-service/action-values.d.ts

@@ -1,23 +1 @@
-import { z } from "zod";
-export declare const ActionValueIdPattern: RegExp;
-export declare const ActionValueIdSchema: z.ZodString;
-export declare const OptionalActionValueIdSchema: z.ZodString;
-export declare const PreparationSetupActionValuesSchema: z.ZodObject<{
-    name: z.ZodString;
-    path: z.ZodString;
-    about: z.ZodString;
-    method: z.ZodOptional<z.ZodString>;
-    readiness_notes: z.ZodOptional<z.ZodString>;
-    prepare_after_setup: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const MethodAuthoringActionValuesSchema: z.ZodObject<{
-    method_id: z.ZodString;
-    label: z.ZodString;
-    hint: z.ZodString;
-    task_prompt: z.ZodString;
-    portable_output: z.ZodOptional<z.ZodString>;
-    readiness_notes: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type PreparationSetupActionValues = z.infer<typeof PreparationSetupActionValuesSchema>;
-export type MethodAuthoringActionValues = z.infer<typeof MethodAuthoringActionValuesSchema>;
-export declare function methodAuthoringTaskPrompt(values: MethodAuthoringActionValues): string;
+export { ActionValueIdPattern, ActionValueIdSchema, MethodAuthoringActionValuesSchema, OptionalActionValueIdSchema, PreparationSetupActionValuesSchema, SourceReadinessCheckActionValueSchema, methodAuthoringRequestFromActionValues, methodAuthoringTaskPrompt, preparationSetupRequestFromActionValues, type MethodAuthoringActionValues, type PreparationSetupActionValues, type SourceReadinessCheckActionValue, } from "./action-definitions.js";

package/dist/packages/local-service/action-values.js

@@ -1,31 +1 @@
-import { z } from "zod";
-export const ActionValueIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
-export const ActionValueIdSchema = z.string().trim().regex(ActionValueIdPattern, "Use lowercase letters, numbers, and dashes.");
-export const OptionalActionValueIdSchema = z.string().trim().refine((value) => value === "" || ActionValueIdPattern.test(value), "Use lowercase letters, numbers, and dashes.");
-export const PreparationSetupActionValuesSchema = z.object({
-    name: ActionValueIdSchema,
-    path: z.string().trim().min(1, "Source Folder is required."),
-    about: z.string().trim().min(1, "Agent work is required."),
-    method: OptionalActionValueIdSchema.optional(),
-    readiness_notes: z.string().trim().optional(),
-    prepare_after_setup: z.boolean().optional(),
-}).strict();
-export const MethodAuthoringActionValuesSchema = z.object({
-    method_id: ActionValueIdSchema,
-    label: z.string().trim().min(1, "Label is required."),
-    hint: z.string().trim().min(1, "Summary is required."),
-    task_prompt: z.string().trim().min(1, "Agent work is required."),
-    portable_output: z.string().trim().optional(),
-    readiness_notes: z.string().trim().optional(),
-}).strict();
-function optionalLine(label, value) {
-    const trimmed = value?.trim();
-    return trimmed ? `${label}: ${trimmed}` : null;
-}
-export function methodAuthoringTaskPrompt(values) {
-    return [
-        `Agent work: ${values.task_prompt}`,
-        optionalLine("Portable-context output", values.portable_output),
-        optionalLine("Readiness checks", values.readiness_notes),
-    ].filter((line) => Boolean(line)).join("\n");
-}
+export { ActionValueIdPattern, ActionValueIdSchema, MethodAuthoringActionValuesSchema, OptionalActionValueIdSchema, PreparationSetupActionValuesSchema, SourceReadinessCheckActionValueSchema, methodAuthoringRequestFromActionValues, methodAuthoringTaskPrompt, preparationSetupRequestFromActionValues, } from "./action-definitions.js";

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

@@ -1,4 +1,4 @@
-import { type CompileRunCreateRequest, type CompileRunListResponse, type CompileRunResource, type LocalJobEventAppendRequest, type LocalJobRunCreateRequest, type LocalJobRunListResponse, type LocalJobRunResource, type LocalServiceHealth, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type ReadinessListResponse, type TestRunCreateRequest, type TestRunListResponse, type TestRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult } from "./lib/schema.js";
+import { type ActionProposalApprovalRequest, type ActionProposalCreateRequest, type ActionProposalResource, type CompileRunCreateRequest, type CompileRunListResponse, type CompileRunResource, type LocalJobRunListResponse, type LocalJobRunResource, type LocalServiceHealth, type MethodChangeCreateRequest, type MethodChangeResult, type PreparationChangeCreateRequest, type PreparationChangeResult, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type ReadinessListResponse, type ResetRequest, type ResetResult, type TestRunCreateRequest, type TestRunListResponse, type TestRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult, type PreparationSetupCreateRequest, type PreparationSetupResult } from "./lib/schema.js";
 export interface LocalServiceConnection {
     serviceUrl: string;
     health: LocalServiceHealth;
@@ -37,6 +37,50 @@ export declare function submitTestRunToLocalService(options: {
     serviceUrl: string;
     resource: TestRunResource;
 } | null>;
+export declare function submitPreparationSetupToLocalService(options: {
+    projectPath: string;
+    request: PreparationSetupCreateRequest;
+}): Promise<{
+    serviceUrl: string;
+    result: PreparationSetupResult;
+} | null>;
+export declare function submitPreparationChangeToLocalService(options: {
+    projectPath: string;
+    request: PreparationChangeCreateRequest;
+}): Promise<{
+    serviceUrl: string;
+    result: PreparationChangeResult;
+} | null>;
+export declare function submitResetToLocalService(options: {
+    projectPath: string;
+    request: ResetRequest;
+}): Promise<{
+    serviceUrl: string;
+    result: ResetResult;
+} | null>;
+export declare function createActionProposalInLocalService(options: {
+    projectPath: string;
+    request: ActionProposalCreateRequest;
+}): Promise<{
+    serviceUrl: string;
+    resource: ActionProposalResource;
+} | null>;
+export declare function decideActionProposalInLocalService(options: {
+    projectPath: string;
+    proposalId: string;
+    request: ActionProposalApprovalRequest;
+    serviceUrl?: string;
+}): Promise<{
+    serviceUrl: string;
+    resource: ActionProposalResource;
+} | null>;
+export declare function approveActionProposalInLocalService(options: {
+    projectPath: string;
+    request: ActionProposalCreateRequest;
+}): Promise<{
+    serviceUrl: string;
+    resource: ActionProposalResource;
+} | null>;
 export declare function getLocalCompileRun(options: {
     serviceUrl: string;
     runId: string;
@@ -100,20 +144,7 @@ export declare function submitMethodAuthoringRunToLocalService(options: {
     onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
     onUpdate?: (job: LocalJobRunResource) => void;
 }): Promise<LocalServiceJobSubmission<MethodAuthoringResult> | null>;
-export interface LocalJobTracker {
-    serviceUrl: string;
-    runId: string;
-    resource: LocalJobRunResource;
-    emit(event: LocalJobEventAppendRequest): void;
-    complete(message?: string): Promise<void>;
-    fail(message: string): Promise<void>;
-}
-export declare function appendLocalJobRunEvent(options: {
-    projectPath: string;
-    runId: string;
-    event: LocalJobEventAppendRequest;
-}): Promise<LocalJobRunResource | null>;
-export declare function startLocalJobRun(options: {
+export declare function submitMethodChangeToLocalService(options: {
     projectPath: string;
-    request: LocalJobRunCreateRequest;
-}): Promise<LocalJobTracker | null>;
+    request: MethodChangeCreateRequest;
+}): Promise<MethodChangeResult | null>;

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

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { CompileRunCreateRequestSchema, CompileRunListResponseSchema, CompileRunResourceSchema, LocalServiceInstancePointerSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunListResponseSchema, LocalJobRunResourceSchema, LocalServiceHealthSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ReadinessListResponseSchema, TestRunCreateRequestSchema, TestRunListResponseSchema, TestRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
-import { LOCAL_SERVICE_INSTANCE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
+import { CompileRunCreateRequestSchema, CompileRunListResponseSchema, CompileRunResourceSchema, ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalResourceSchema, LocalServicePointerSchema, LocalJobRunListResponseSchema, LocalJobRunResourceSchema, LocalServiceHealthSchema, MethodChangeCreateRequestSchema, MethodChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ReadinessListResponseSchema, ResetRequestSchema, ResetResultSchema, TestRunCreateRequestSchema, TestRunListResponseSchema, TestRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
+import { LOCAL_SERVICE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/, "");
 }
@@ -12,11 +12,11 @@ export function configuredLocalServiceUrl() {
     return buildLocalServiceUrl();
 }
 function projectLocalServiceUrl(projectPath) {
-    const pointerPath = join(projectPath, ...LOCAL_SERVICE_INSTANCE_POINTER_PATH);
+    const pointerPath = join(projectPath, ...LOCAL_SERVICE_POINTER_PATH);
     if (!existsSync(pointerPath))
         return null;
     try {
-        const pointer = LocalServiceInstancePointerSchema.parse(JSON.parse(readFileSync(pointerPath, "utf8")));
+        const pointer = LocalServicePointerSchema.parse(JSON.parse(readFileSync(pointerPath, "utf8")));
         return trimTrailingSlash(pointer.service_url);
     }
     catch {
@@ -108,6 +108,92 @@ export async function submitTestRunToLocalService(options) {
         resource,
     };
 }
+export async function submitPreparationSetupToLocalService(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = PreparationSetupCreateRequestSchema.parse(options.request);
+    const result = PreparationSetupResultSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.preparationSetups}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    return {
+        serviceUrl: connection.serviceUrl,
+        result,
+    };
+}
+export async function submitPreparationChangeToLocalService(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = PreparationChangeCreateRequestSchema.parse(options.request);
+    const result = PreparationChangeResultSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.preparationChanges}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    return {
+        serviceUrl: connection.serviceUrl,
+        result,
+    };
+}
+export async function submitResetToLocalService(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = ResetRequestSchema.parse(options.request);
+    const result = ResetResultSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.reset}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    return {
+        serviceUrl: connection.serviceUrl,
+        result,
+    };
+}
+export async function createActionProposalInLocalService(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = ActionProposalCreateRequestSchema.parse(options.request);
+    const resource = ActionProposalResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.actionProposals}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    return {
+        serviceUrl: connection.serviceUrl,
+        resource,
+    };
+}
+export async function decideActionProposalInLocalService(options) {
+    const connection = options.serviceUrl
+        ? { serviceUrl: options.serviceUrl }
+        : await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = ActionProposalApprovalRequestSchema.parse(options.request);
+    const resource = ActionProposalResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.actionProposals}/${encodeURIComponent(options.proposalId)}/decision`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    return {
+        serviceUrl: connection.serviceUrl,
+        resource,
+    };
+}
+export async function approveActionProposalInLocalService(options) {
+    const proposal = await createActionProposalInLocalService(options);
+    if (!proposal)
+        return null;
+    if (proposal.resource.status !== "awaiting_approval")
+        return proposal;
+    const decided = await decideActionProposalInLocalService({
+        projectPath: options.projectPath,
+        proposalId: proposal.resource.proposal_id,
+        request: { approved: true },
+        serviceUrl: proposal.serviceUrl,
+    });
+    return decided ?? proposal;
+}
 function isTerminalJobStatus(status) {
     return status === "succeeded" || status === "failed" || status === "cancelled";
 }
@@ -242,7 +328,7 @@ export async function submitReadinessCheckDraftToLocalService(options) {
             serviceUrl: connection.serviceUrl,
             job,
             result: null,
-            error: resultError(job, "Readiness-check drafting failed in the local Interf service."),
+            error: resultError(job, "Drafting readiness checks failed in the local Interf service."),
         };
     }
     const parsed = ReadinessCheckDraftResultSchema.safeParse(job.result);
@@ -251,7 +337,7 @@ export async function submitReadinessCheckDraftToLocalService(options) {
             serviceUrl: connection.serviceUrl,
             job,
             result: null,
-            error: "Readiness-check drafting finished without a valid result.",
+            error: "Drafting readiness checks finished without a valid result.",
         };
     }
     return {
@@ -301,56 +387,13 @@ export async function submitMethodAuthoringRunToLocalService(options) {
         result: parsed.data,
     };
 }
-export async function appendLocalJobRunEvent(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
-    if (!connection)
-        return null;
-    const event = LocalJobEventAppendRequestSchema.parse(options.event);
-    return LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.jobs}/${encodeURIComponent(options.runId)}/events`, {
-        method: "POST",
-        body: JSON.stringify(event),
-    }));
-}
-export async function startLocalJobRun(options) {
+export async function submitMethodChangeToLocalService(options) {
     const connection = await findLocalService({ projectPath: options.projectPath });
     if (!connection)
         return null;
-    const request = LocalJobRunCreateRequestSchema.parse(options.request);
-    const resource = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.jobs}`, {
+    const request = MethodChangeCreateRequestSchema.parse(options.request);
+    return MethodChangeResultSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.methodChanges}`, {
         method: "POST",
         body: JSON.stringify(request),
     }));
-    const emit = (event) => {
-        void appendLocalJobRunEvent({
-            projectPath: options.projectPath,
-            runId: resource.run_id,
-            event,
-        }).catch(() => { });
-    };
-    return {
-        serviceUrl: connection.serviceUrl,
-        runId: resource.run_id,
-        resource,
-        emit,
-        complete: async (message) => {
-            await appendLocalJobRunEvent({
-                projectPath: options.projectPath,
-                runId: resource.run_id,
-                event: {
-                    type: "job.completed",
-                    ...(message ? { message } : {}),
-                },
-            });
-        },
-        fail: async (message) => {
-            await appendLocalJobRunEvent({
-                projectPath: options.projectPath,
-                runId: resource.run_id,
-                event: {
-                    type: "job.failed",
-                    message,
-                },
-            });
-        },
-    };
 }

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

@@ -1,15 +1,18 @@
 export * as schema from "./lib/schema.js";
 export * as actionValues from "./action-values.js";
+export * as actionDefinitions from "./action-definitions.js";
 export * as routes from "./routes.js";
 export * as client from "./client.js";
 export * as runtime from "./runtime.js";
 export * as server from "./server.js";
-export type { CompileRunCreateRequest, CompileRunResource, CompileRunSummary, LocalServiceDiscovery, PortableContextMapping, PreparationReadinessState, PreparationRunLinkage, PreparationResource, MethodResource, LocalJobAgent, LocalJobEvent, LocalJobEventAppendRequest, LocalJobEventType, LocalJobRunCreateRequest, LocalJobRunListResponse, LocalJobRunResource, LocalJobStatus, LocalRunHandlerResult, LocalJobStep, LocalJobType, LocalServiceConfig, LocalServiceHealth, LocalServiceInstancePointer, LocalServiceResource, LocalExecutorStatus, ActionProposalApproval, ActionProposalApprovalRequest, ActionProposalCreateRequest, ActionProposalListResponse, ActionProposalPlan, ActionProposalResource, ActionProposalStatus, ActionProposalType, PreparationSetupCreateRequest, PortableContextResource, ReadinessListResponse, ReadinessResource, SourceFileResource, WorkspaceFileResource, ReadinessCheckDraftCreateRequest, ReadinessCheckDraftResult, TestRunCreateRequest, TestRunResource, TestRunStatus, RunCreateRequest, RunObservabilityListResponse, RunObservabilityResource, MethodAuthoringCreateRequest, MethodAuthoringResult, PreparationListResponse, MethodListResponse, CompileRunListResponse, TestRunListResponse, PortableContextListResponse, SourceFileListResponse, WorkspaceFileListResponse, OpenPathRequest, OpenPathResponse, } from "./lib/schema.js";
-export { CompileRunCreateRequestSchema, CompileRunResourceSchema, CompileRunSummarySchema, LocalServiceDiscoverySchema, PortableContextMappingSchema, PreparationReadinessStateSchema, PreparationRunLinkageSchema, PreparationResourceSchema, MethodResourceSchema, LocalJobAgentSchema, LocalJobEventAppendRequestSchema, LocalJobEventSchema, LocalJobEventTypeSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, LocalJobStatusSchema, LocalRunHandlerResultSchema, LocalJobStepSchema, LocalJobTypeSchema, LocalServiceConfigSchema, LocalServiceHealthSchema, LocalServiceInstancePointerSchema, LocalServiceResourceSchema, PortableContextResourceSchema, ReadinessResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, TestRunCreateRequestSchema, TestRunResourceSchema, TestRunStatusSchema, RunCreateRequestSchema, RunObservabilityResourceSchema, RunObservabilityListResponseSchema, LocalExecutorStatusSchema, ActionProposalApprovalRequestSchema, ActionProposalApprovalSchema, ActionProposalCreateRequestSchema, ActionProposalListResponseSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalStatusSchema, ActionProposalTypeSchema, PreparationSetupCreateRequestSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, PreparationListResponseSchema, MethodListResponseSchema, CompileRunListResponseSchema, LocalJobRunListResponseSchema, TestRunListResponseSchema, PortableContextListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, WorkspaceFileListResponseSchema, OpenPathRequestSchema, OpenPathResponseSchema, } from "./lib/schema.js";
-export { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_INSTANCE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
-export type { LocalServiceJobSubmission, LocalServiceJobSubmitted, LocalServiceConnection, LocalServiceRunSnapshot, LocalJobTracker, } from "./client.js";
-export { appendLocalJobRunEvent, configuredLocalServiceUrl, findLocalService, getLocalJobRun, getLocalCompileRun, getLocalTestRun, listLocalCompileRuns, listLocalJobRuns, listLocalTestRuns, readLocalServiceRunSnapshot, startLocalJobRun, submitCompileRunToLocalService, submitReadinessCheckDraftToLocalService, submitTestRunToLocalService, submitMethodAuthoringRunToLocalService, waitForLocalJobRun, waitForLocalCompileRun, waitForLocalTestRun, } from "./client.js";
+export type { CompileRunCreateRequest, CompileRunResource, CompileRunSummary, LocalServiceDiscovery, PortableContextMapping, PreparationReadinessState, PreparationRunLinkage, PreparationResource, MethodResource, LocalJobAgent, LocalJobEvent, LocalJobEventAppendRequest, LocalJobEventType, LocalJobRunCreateRequest, LocalJobRunListResponse, LocalJobRunResource, LocalJobStatus, LocalRunHandlerResult, LocalJobStep, LocalJobType, LocalServiceConfig, LocalServiceError, LocalServiceHealth, LocalServicePointer, LocalServiceResource, LocalExecutorStatus, ActionClientOrigin, ActionProposalApproval, ActionProposalApprovalRequest, ActionProposalCreateRequest, ActionProposalListResponse, ActionProposalPlan, ActionProposalPlanActionType, ActionProposalResource, ActionProposalStatus, ActionProposalType, MethodChangeCreateRequest, MethodChangeResult, PreparationChangeCreateRequest, PreparationChangeResult, ResetRequest, ResetResult, PreparationSetupCreateRequest, PreparationSetupResult, PortableContextResource, ReadinessListResponse, ReadinessResource, SourceFileResource, WorkspaceFileResource, ReadinessCheckDraftCreateRequest, ReadinessCheckDraftResult, TestRunCreateRequest, TestRunResource, TestRunStatus, RunObservabilityListResponse, RunObservabilityResource, MethodAuthoringCreateRequest, MethodAuthoringResult, PreparationListResponse, MethodListResponse, CompileRunListResponse, TestRunListResponse, PortableContextListResponse, SourceFileListResponse, WorkspaceFileListResponse, OpenPathRequest, OpenPathResponse, } from "./lib/schema.js";
+export { CompileRunCreateRequestSchema, CompileRunResourceSchema, CompileRunSummarySchema, LocalServiceDiscoverySchema, PortableContextMappingSchema, PreparationReadinessStateSchema, PreparationRunLinkageSchema, PreparationResourceSchema, MethodResourceSchema, LocalJobAgentSchema, LocalJobEventAppendRequestSchema, LocalJobEventSchema, LocalJobEventTypeSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, LocalJobStatusSchema, LocalRunHandlerResultSchema, LocalJobStepSchema, LocalJobTypeSchema, LocalServiceConfigSchema, LocalServiceErrorSchema, LocalServiceHealthSchema, LocalServicePointerSchema, LocalServiceResourceSchema, PortableContextResourceSchema, ReadinessResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, TestRunCreateRequestSchema, TestRunResourceSchema, TestRunStatusSchema, RunObservabilityResourceSchema, RunObservabilityListResponseSchema, LocalExecutorStatusSchema, ActionClientOriginSchema, ActionProposalApprovalRequestSchema, ActionProposalApprovalSchema, ActionProposalCreateRequestSchema, ActionProposalListResponseSchema, ActionProposalPlanSchema, ActionProposalPlanActionTypeSchema, ActionProposalResourceSchema, ActionProposalStatusSchema, ActionProposalTypeSchema, MethodChangeCreateRequestSchema, MethodChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, ResetRequestSchema, ResetResultSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, PreparationListResponseSchema, MethodListResponseSchema, CompileRunListResponseSchema, LocalJobRunListResponseSchema, TestRunListResponseSchema, PortableContextListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, WorkspaceFileListResponseSchema, OpenPathRequestSchema, OpenPathResponseSchema, } from "./lib/schema.js";
+export { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
+export type { LocalServiceJobSubmission, LocalServiceJobSubmitted, LocalServiceConnection, LocalServiceRunSnapshot, } from "./client.js";
+export { approveActionProposalInLocalService, configuredLocalServiceUrl, createActionProposalInLocalService, decideActionProposalInLocalService, findLocalService, getLocalJobRun, getLocalCompileRun, getLocalTestRun, listLocalCompileRuns, listLocalJobRuns, listLocalTestRuns, readLocalServiceRunSnapshot, submitCompileRunToLocalService, submitMethodChangeToLocalService, submitPreparationChangeToLocalService, submitPreparationSetupToLocalService, submitReadinessCheckDraftToLocalService, submitResetToLocalService, submitTestRunToLocalService, submitMethodAuthoringRunToLocalService, waitForLocalJobRun, waitForLocalCompileRun, waitForLocalTestRun, } from "./client.js";
 export type { LocalServiceActionPlanningContext, LocalServiceCompileRunContext, LocalServiceJobRunContext, LocalServiceRunHandlers, LocalServiceRuntimeOptions, LocalServiceTestRunContext, } from "./runtime.js";
 export { LocalServiceRuntime, createLocalServiceRuntime, } from "./runtime.js";
 export type { StartedLocalService, StartLocalServiceOptions, } from "./server.js";
 export { createLocalServiceServer, startLocalService, } from "./server.js";
+export type { NativeLocalServiceRunHandlerOptions, } from "./native-run-handlers.js";
+export { createNativeLocalServiceRunHandlers, } from "./native-run-handlers.js";

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

@@ -1,11 +1,13 @@
 export * as schema from "./lib/schema.js";
 export * as actionValues from "./action-values.js";
+export * as actionDefinitions from "./action-definitions.js";
 export * as routes from "./routes.js";
 export * as client from "./client.js";
 export * as runtime from "./runtime.js";
 export * as server from "./server.js";
-export { CompileRunCreateRequestSchema, CompileRunResourceSchema, CompileRunSummarySchema, LocalServiceDiscoverySchema, PortableContextMappingSchema, PreparationReadinessStateSchema, PreparationRunLinkageSchema, PreparationResourceSchema, MethodResourceSchema, LocalJobAgentSchema, LocalJobEventAppendRequestSchema, LocalJobEventSchema, LocalJobEventTypeSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, LocalJobStatusSchema, LocalRunHandlerResultSchema, LocalJobStepSchema, LocalJobTypeSchema, LocalServiceConfigSchema, LocalServiceHealthSchema, LocalServiceInstancePointerSchema, LocalServiceResourceSchema, PortableContextResourceSchema, ReadinessResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, TestRunCreateRequestSchema, TestRunResourceSchema, TestRunStatusSchema, RunCreateRequestSchema, RunObservabilityResourceSchema, RunObservabilityListResponseSchema, LocalExecutorStatusSchema, ActionProposalApprovalRequestSchema, ActionProposalApprovalSchema, ActionProposalCreateRequestSchema, ActionProposalListResponseSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalStatusSchema, ActionProposalTypeSchema, PreparationSetupCreateRequestSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, PreparationListResponseSchema, MethodListResponseSchema, CompileRunListResponseSchema, LocalJobRunListResponseSchema, TestRunListResponseSchema, PortableContextListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, WorkspaceFileListResponseSchema, OpenPathRequestSchema, OpenPathResponseSchema, } from "./lib/schema.js";
-export { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_INSTANCE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
-export { appendLocalJobRunEvent, configuredLocalServiceUrl, findLocalService, getLocalJobRun, getLocalCompileRun, getLocalTestRun, listLocalCompileRuns, listLocalJobRuns, listLocalTestRuns, readLocalServiceRunSnapshot, startLocalJobRun, submitCompileRunToLocalService, submitReadinessCheckDraftToLocalService, submitTestRunToLocalService, submitMethodAuthoringRunToLocalService, waitForLocalJobRun, waitForLocalCompileRun, waitForLocalTestRun, } from "./client.js";
+export { CompileRunCreateRequestSchema, CompileRunResourceSchema, CompileRunSummarySchema, LocalServiceDiscoverySchema, PortableContextMappingSchema, PreparationReadinessStateSchema, PreparationRunLinkageSchema, PreparationResourceSchema, MethodResourceSchema, LocalJobAgentSchema, LocalJobEventAppendRequestSchema, LocalJobEventSchema, LocalJobEventTypeSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, LocalJobStatusSchema, LocalRunHandlerResultSchema, LocalJobStepSchema, LocalJobTypeSchema, LocalServiceConfigSchema, LocalServiceErrorSchema, LocalServiceHealthSchema, LocalServicePointerSchema, LocalServiceResourceSchema, PortableContextResourceSchema, ReadinessResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, TestRunCreateRequestSchema, TestRunResourceSchema, TestRunStatusSchema, RunObservabilityResourceSchema, RunObservabilityListResponseSchema, LocalExecutorStatusSchema, ActionClientOriginSchema, ActionProposalApprovalRequestSchema, ActionProposalApprovalSchema, ActionProposalCreateRequestSchema, ActionProposalListResponseSchema, ActionProposalPlanSchema, ActionProposalPlanActionTypeSchema, ActionProposalResourceSchema, ActionProposalStatusSchema, ActionProposalTypeSchema, MethodChangeCreateRequestSchema, MethodChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, ResetRequestSchema, ResetResultSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, PreparationListResponseSchema, MethodListResponseSchema, CompileRunListResponseSchema, LocalJobRunListResponseSchema, TestRunListResponseSchema, PortableContextListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, WorkspaceFileListResponseSchema, OpenPathRequestSchema, OpenPathResponseSchema, } from "./lib/schema.js";
+export { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
+export { approveActionProposalInLocalService, configuredLocalServiceUrl, createActionProposalInLocalService, decideActionProposalInLocalService, findLocalService, getLocalJobRun, getLocalCompileRun, getLocalTestRun, listLocalCompileRuns, listLocalJobRuns, listLocalTestRuns, readLocalServiceRunSnapshot, submitCompileRunToLocalService, submitMethodChangeToLocalService, submitPreparationChangeToLocalService, submitPreparationSetupToLocalService, submitReadinessCheckDraftToLocalService, submitResetToLocalService, submitTestRunToLocalService, submitMethodAuthoringRunToLocalService, waitForLocalJobRun, waitForLocalCompileRun, waitForLocalTestRun, } from "./client.js";
 export { LocalServiceRuntime, createLocalServiceRuntime, } from "./runtime.js";
 export { createLocalServiceServer, startLocalService, } from "./server.js";
+export { createNativeLocalServiceRunHandlers, } from "./native-run-handlers.js";