@interf/compiler 0.9.4 → 0.13.0

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,135 @@
+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 { asPreparationDataDir, preparationServiceActionPlansRoot, } from "../contracts/lib/preparation-paths.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(preparationServiceActionPlansRoot(asPreparationDataDir(options.context.sourcePath)), 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,7 +1,12 @@
-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 CompileRunResource, type LocalJobRunResource, type LocalServiceHealth, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type ResetRequest, type ResetResult, type TestRunCreateRequest, type TestRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult } from "./lib/schema.js";
+export interface FindOrStartLocalServiceOptions {
+    url?: string;
+    authToken?: string;
+}
 export interface LocalServiceConnection {
     serviceUrl: string;
     health: LocalServiceHealth;
+    authToken: string | null;
 }
 export interface LocalServiceJobSubmission<T> {
     serviceUrl: string;
@@ -13,107 +18,132 @@ export interface LocalServiceJobSubmitted {
     serviceUrl: string;
     job: LocalJobRunResource;
 }
-export interface LocalServiceRunSnapshot {
-    jobs: LocalJobRunResource[];
-    compileRuns: CompileRunResource[];
-    testRuns: TestRunResource[];
-}
 export declare function configuredLocalServiceUrl(): string;
-export declare function findLocalService(options: {
-    projectPath: string;
+/**
+ * Resolve the bearer token for the active connection. In 0.13 there is
+ * exactly one source of truth: `~/.interf/connection.json` (or the
+ * `INTERF_SERVICE_TOKEN` env override).
+ */
+export declare function resolveLocalServiceAuthToken(): string | null;
+/**
+ * Resolve a connection. In 0.13 this is the only path to the engine — read
+ * `~/.interf/connection.json` (written by `interf web`) or honor the
+ * `INTERF_SERVICE_URL` / `INTERF_SERVICE_TOKEN` env overrides.
+ */
+export declare function findLocalService(options?: {
     timeoutMs?: number;
 }): Promise<LocalServiceConnection | null>;
 export declare function submitCompileRunToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: CompileRunCreateRequest;
+    idempotencyKey?: string;
 }): Promise<{
     serviceUrl: string;
     resource: CompileRunResource;
 } | null>;
 export declare function submitTestRunToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: TestRunCreateRequest;
 }): Promise<{
     serviceUrl: string;
     resource: TestRunResource;
 } | null>;
+export declare function submitResetToLocalService(options: {
+    preparationId: string;
+    request: ResetRequest;
+}): Promise<{
+    serviceUrl: string;
+    result: ResetResult;
+} | null>;
+export declare function createActionProposalInLocalService(options: {
+    request: ActionProposalCreateRequest;
+}): Promise<{
+    serviceUrl: string;
+    resource: ActionProposalResource;
+} | null>;
+export declare function decideActionProposalInLocalService(options: {
+    proposalId: string;
+    request: ActionProposalApprovalRequest;
+    serviceUrl?: string;
+    authToken?: string | null;
+}): Promise<{
+    serviceUrl: string;
+    resource: ActionProposalResource;
+} | null>;
+export declare function approveActionProposalInLocalService(options: {
+    request: ActionProposalCreateRequest;
+}): Promise<{
+    serviceUrl: string;
+    resource: ActionProposalResource;
+} | null>;
 export declare function getLocalCompileRun(options: {
     serviceUrl: string;
     runId: string;
+    authToken?: string | null;
 }): Promise<CompileRunResource>;
-export declare function listLocalCompileRuns(options: {
-    serviceUrl: string;
-    timeoutMs?: number;
-}): Promise<CompileRunListResponse>;
-export declare function listLocalReadiness(options: {
+export interface LocalCompileRunCancelResult {
+    cancelled: boolean;
+    reason?: string;
+}
+/**
+ * Ask the local service to cancel a running compile run by id. Resolves
+ * with the typed cancel result on success and throws when the service
+ * returns 404 (unknown run id) or any non-2xx status.
+ */
+export declare function cancelLocalCompileRun(options: {
     serviceUrl: string;
+    runId: string;
     timeoutMs?: number;
-}): Promise<ReadinessListResponse>;
+    authToken?: string | null;
+}): Promise<LocalCompileRunCancelResult>;
 export declare function waitForLocalCompileRun(options: {
     serviceUrl: string;
     runId: string;
     pollMs?: number;
+    authToken?: string | null;
     onUpdate?: (resource: CompileRunResource) => void;
 }): Promise<CompileRunResource>;
 export declare function getLocalTestRun(options: {
     serviceUrl: string;
     runId: string;
+    authToken?: string | null;
 }): Promise<TestRunResource>;
-export declare function listLocalTestRuns(options: {
-    serviceUrl: string;
-    timeoutMs?: number;
-}): Promise<TestRunListResponse>;
 export declare function waitForLocalTestRun(options: {
     serviceUrl: string;
     runId: string;
     pollMs?: number;
+    authToken?: string | null;
     onUpdate?: (resource: TestRunResource) => void;
 }): Promise<TestRunResource>;
 export declare function getLocalJobRun(options: {
     serviceUrl: string;
     runId: string;
+    authToken?: string | null;
 }): Promise<LocalJobRunResource>;
-export declare function listLocalJobRuns(options: {
-    serviceUrl: string;
-    timeoutMs?: number;
-}): Promise<LocalJobRunListResponse>;
-export declare function readLocalServiceRunSnapshot(options: {
-    serviceUrl: string;
-    timeoutMs?: number;
-}): Promise<LocalServiceRunSnapshot>;
 export declare function waitForLocalJobRun(options: {
     serviceUrl: string;
     runId: string;
     pollMs?: number;
     timeoutMs?: number;
+    authToken?: string | null;
     onUpdate?: (job: LocalJobRunResource) => void;
 }): Promise<LocalJobRunResource>;
 export declare function submitReadinessCheckDraftToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: ReadinessCheckDraftCreateRequest;
     onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
     onUpdate?: (job: LocalJobRunResource) => void;
 }): Promise<LocalServiceJobSubmission<ReadinessCheckDraftResult> | null>;
 export declare function submitMethodAuthoringRunToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: MethodAuthoringCreateRequest;
     onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
     onUpdate?: (job: LocalJobRunResource) => void;
 }): Promise<LocalServiceJobSubmission<MethodAuthoringResult> | null>;
-export interface LocalJobTracker {
+/**
+ * Fetch the engine instance health/status.
+ */
+export declare function getLocalServiceHealth(options: {
     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: {
-    projectPath: string;
-    request: LocalJobRunCreateRequest;
-}): Promise<LocalJobTracker | null>;
+    timeoutMs?: number;
+}): Promise<LocalServiceHealth>;