@interf/compiler 0.9.4 → 0.13.0

package/dist/cli/commands/default.js

@@ -1,39 +0,0 @@
-import chalk from "chalk";
-import { userConfig } from "../../packages/agents/index.js";
-import { runInitCommand } from "./init.js";
-function printStaticLanding() {
-    const config = userConfig.loadUserConfig();
-    console.log();
-    console.log(chalk.bold("  Interf"));
-    console.log(chalk.dim("  Prepare data for agent work."));
-    console.log(chalk.dim("  Run locally, process files, show evidence that your data is ready, and write verifiable outputs as Portable Context for agents."));
-    console.log();
-    if (config) {
-        console.log(chalk.dim(`  Agent: ${config.agent}`));
-        console.log();
-    }
-    console.log(chalk.dim("  Suggested flow:"));
-    console.log(chalk.dim("    interf"));
-    console.log(chalk.dim("    interf web      # optional local UI/API"));
-    console.log(chalk.dim("    interf compile"));
-    console.log(chalk.dim("    interf test"));
-    console.log(chalk.dim("    interf test --target source-files   # optional baseline before compile"));
-    console.log();
-    console.log(chalk.dim("  More:"));
-    console.log(chalk.dim("    interf init"));
-    console.log(chalk.dim("    interf create method"));
-    console.log(chalk.dim("    interf doctor --live"));
-    console.log(chalk.dim("    interf --help"));
-    console.log();
-}
-export const defaultCommand = {
-    command: "$0",
-    describe: false,
-    handler: async () => {
-        if (!process.stdin.isTTY || !process.stdout.isTTY) {
-            printStaticLanding();
-            return;
-        }
-        await runInitCommand();
-    },
-};

package/dist/cli/commands/executor-flow.d.ts

@@ -1,29 +0,0 @@
-import { type MethodExecutionProfile, type MethodExecutor } from "../../packages/agents/index.js";
-export interface RunAgentOption {
-    name: string;
-    displayName: string;
-    command: string;
-    current: boolean;
-}
-export declare function resolvedConfiguredAgentName(): string | null;
-export declare function listRunAgentOptions(): RunAgentOption[];
-export declare function resolveNamedLocalExecutor(agentName: string, options?: {
-    preflight?: boolean;
-    executionProfile?: MethodExecutionProfile;
-}): {
-    executor: MethodExecutor | null;
-    error?: string;
-};
-export declare function promptForTestAgents(): Promise<{
-    agents: RunAgentOption[];
-    cancelled: boolean;
-}>;
-export declare function resolveOrConfigureLocalExecutor(options?: {
-    preflight?: boolean;
-    executionProfile?: MethodExecutionProfile;
-    purpose?: "compile" | "test" | "draft" | "method";
-}): Promise<{
-    executor: MethodExecutor | null;
-    error?: string;
-    cancelled?: boolean;
-}>;

package/dist/cli/commands/executor-flow.js

@@ -1,163 +0,0 @@
-import * as p from "@clack/prompts";
-import { constants, agents, executors, userConfig } from "../../packages/agents/index.js";
-const promptedPurposes = new Set();
-function supportedDetectedAgents() {
-    return agents.detectAgents().filter((agent) => constants.AGENTS.some((candidate) => candidate.name === agent.name) && agents.supportsAutomatedRuns(agent));
-}
-export function resolvedConfiguredAgentName() {
-    const current = userConfig.loadUserConfig();
-    if (!current)
-        return null;
-    const configured = constants.AGENTS.find((agent) => agent.command === current.agentCommand) ??
-        constants.AGENTS.find((agent) => agent.name === current.agent) ??
-        constants.AGENTS.find((agent) => agent.displayName === current.agent);
-    return configured?.name ?? null;
-}
-function persistSelectedAgent(selectedName) {
-    const selected = supportedDetectedAgents().find((agent) => agent.name === selectedName);
-    if (!selected)
-        return;
-    const current = userConfig.loadUserConfig();
-    userConfig.saveUserConfig({
-        agent: selected.name,
-        agentCommand: selected.command,
-        skillsInstalled: current?.skillsInstalled ?? false,
-        initialized: current?.initialized ?? new Date().toISOString(),
-    });
-}
-export function listRunAgentOptions() {
-    const configuredName = resolvedConfiguredAgentName();
-    return supportedDetectedAgents().map((agent) => ({
-        name: agent.name,
-        displayName: agent.displayName,
-        command: agent.command,
-        current: agent.name === configuredName,
-    }));
-}
-export function resolveNamedLocalExecutor(agentName, options = {}) {
-    const agent = supportedDetectedAgents().find((entry) => entry.name === agentName);
-    if (!agent) {
-        return { executor: null, error: `Local agent \"${agentName}\" is not detected.` };
-    }
-    if (options.preflight !== false) {
-        const readiness = agents.ensureAgentAutomatedRunReady(agent);
-        if (!readiness.ok) {
-            return { executor: null, error: readiness.error };
-        }
-    }
-    return {
-        executor: executors.createLocalAgentExecutor(agent, options.executionProfile),
-    };
-}
-export async function promptForTestAgents() {
-    const detected = listRunAgentOptions();
-    if (detected.length === 0)
-        return { agents: [], cancelled: false };
-    if (detected.length === 1) {
-        const only = detected[0];
-        if (only) {
-            persistSelectedAgent(only.name);
-            p.log.info(`Local agent for this test: ${only.displayName}`);
-            return { agents: [only], cancelled: false };
-        }
-    }
-    const current = detected.find((agent) => agent.current) ?? detected[0] ?? null;
-    const selected = await p.multiselect({
-        message: current
-            ? `Which local agents should run this test? Current: ${current.displayName}`
-            : "Which local agents should run this test?",
-        options: detected.map((agent) => ({
-            value: agent.name,
-            label: agent.current ? `${agent.displayName} (Current)` : agent.displayName,
-            hint: agent.command,
-        })),
-        required: false,
-        initialValues: current ? [current.name] : [],
-    });
-    if (p.isCancel(selected)) {
-        return { agents: [], cancelled: true };
-    }
-    const selectedNames = Array.isArray(selected) ? selected.map(String) : [];
-    const agents = detected.filter((agent) => selectedNames.includes(agent.name));
-    if (agents.length === 1 && agents[0]) {
-        persistSelectedAgent(agents[0].name);
-    }
-    return { agents, cancelled: false };
-}
-async function promptForRunAgent(purpose) {
-    const purposeLabel = purpose === "draft"
-        ? "check draft"
-        : purpose === "method"
-            ? "Method authoring"
-            : purpose;
-    const detected = supportedDetectedAgents();
-    if (detected.length === 0)
-        return { selected: false, cancelled: false };
-    const configuredName = resolvedConfiguredAgentName();
-    const currentAgent = detected.find((agent) => agent.name === configuredName) ??
-        (detected.length === 1 ? detected[0] ?? null : null);
-    let selectedName = null;
-    if (detected.length === 1) {
-        p.log.info(`Local agent for this ${purposeLabel}: ${detected[0]?.displayName ?? "unknown"}`);
-        const confirmed = await p.confirm({
-            message: `Run this ${purposeLabel} with ${detected[0]?.displayName ?? "the detected agent"}?`,
-            initialValue: true,
-        });
-        if (p.isCancel(confirmed) || !confirmed) {
-            return { selected: false, cancelled: true };
-        }
-        selectedName = detected[0]?.name ?? null;
-    }
-    else {
-        selectedName = await p.select({
-            message: currentAgent
-                ? `Local agent for this ${purposeLabel}? Current: ${currentAgent.displayName}`
-                : `Which local agent should run this ${purposeLabel}?`,
-            options: detected.map((agent) => ({
-                value: agent.name,
-                label: agent.name === currentAgent?.name ? `${agent.displayName} (Current)` : agent.displayName,
-                hint: agent.command,
-            })),
-        });
-    }
-    if (!selectedName || p.isCancel(selectedName)) {
-        return { selected: false, cancelled: true };
-    }
-    persistSelectedAgent(String(selectedName));
-    const selected = detected.find((agent) => agent.name === selectedName);
-    if (selected) {
-        p.log.info(`Using ${selected.displayName} for this run.`);
-    }
-    return { selected: true, cancelled: false };
-}
-export async function resolveOrConfigureLocalExecutor(options = {}) {
-    if (options.purpose &&
-        process.stdin.isTTY &&
-        process.stdout.isTTY &&
-        !promptedPurposes.has(options.purpose)) {
-        const configured = await promptForRunAgent(options.purpose);
-        promptedPurposes.add(options.purpose);
-        if (configured.cancelled) {
-            return { executor: null, cancelled: true };
-        }
-        if (!configured.selected) {
-            return { executor: null, error: "No local agent detected." };
-        }
-    }
-    const resolved = executors.resolveLocalExecutor(options);
-    if (resolved.executor)
-        return resolved;
-    const needsChoice = typeof resolved.error === "string" &&
-        /Multiple coding agents detected|Configured agent .*not available in PATH|Configured agent .*is not supported|Configured agent .*can only automate/i.test(resolved.error);
-    if (!needsChoice) {
-        return resolved;
-    }
-    const configured = await promptForRunAgent(options.purpose ?? "run");
-    if (configured.cancelled) {
-        return { executor: null, cancelled: true };
-    }
-    if (!configured.selected) {
-        return resolved;
-    }
-    return executors.resolveLocalExecutor(options);
-}

package/dist/cli/commands/init.d.ts

@@ -1,11 +0,0 @@
-import type { CommandModule } from "yargs";
-import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
-import { type AgentTestMatrixRow } from "./test-flow.js";
-import { runCompileCommand } from "./compile.js";
-export type CurrentRunTargetStatus = "pass" | "mixed" | "fail" | "missing";
-export declare function currentRunTargetStatus(rows: AgentTestMatrixRow[], target: "raw" | "compiled"): CurrentRunTargetStatus;
-export declare function compileSelectedCompiled(sourcePath: string, compiledConfig: SourcePreparationConfig, deps?: {
-    runCompileCommand?: typeof runCompileCommand;
-}): Promise<import("./compile.js").CompileCommandResult | null>;
-export declare const initCommand: CommandModule;
-export declare function runInitCommand(): Promise<void>;