@delegance/claude-autopilot 5.2.2 → 6.2.2

package/dist/src/adapters/sdk-loader.js

@@ -0,0 +1,77 @@
+// src/adapters/sdk-loader.ts
+//
+// Lazy-load LLM SDKs via dynamic import so the package doesn't pay the boot
+// cost (or install footprint) for providers the user isn't using. The four
+// LLM SDKs together account for ~26 MB of node_modules; users with only one
+// API key need only one of them.
+//
+// On a missing SDK, throw a `GuardrailError` with the exact `npm install`
+// command — same UX as a missing API key.
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { GuardrailError } from "../core/errors.js";
+function isModuleNotFound(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const code = err.code;
+    return code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND';
+}
+function missingSdkError(pkg, provider) {
+    return new GuardrailError(`${pkg} not installed — run: npm install ${pkg}`, { code: 'auth', provider });
+}
+export async function loadAnthropic() {
+    try {
+        const mod = await import('@anthropic-ai/sdk');
+        return (mod.default ?? mod);
+    }
+    catch (err) {
+        if (isModuleNotFound(err))
+            throw missingSdkError('@anthropic-ai/sdk', 'claude');
+        throw err;
+    }
+}
+export async function loadOpenAI() {
+    try {
+        const mod = await import('openai');
+        return (mod.default ?? mod);
+    }
+    catch (err) {
+        if (isModuleNotFound(err))
+            throw missingSdkError('openai', 'openai');
+        throw err;
+    }
+}
+export async function loadGoogleGenerativeAI() {
+    try {
+        const mod = await import('@google/generative-ai');
+        return mod.GoogleGenerativeAI;
+    }
+    catch (err) {
+        if (isModuleNotFound(err))
+            throw missingSdkError('@google/generative-ai', 'gemini');
+        throw err;
+    }
+}
+/**
+ * Quick non-throwing check — used by `doctor` to report install state.
+ */
+export async function isSdkInstalled(pkg) {
+    try {
+        await import(__rewriteRelativeImportExtension(pkg));
+        return true;
+    }
+    catch (err) {
+        if (isModuleNotFound(err))
+            return false;
+        // Other errors (e.g., the SDK itself failed to load) — count as installed
+        // but broken; doctor will surface that separately if needed.
+        return true;
+    }
+}
+//# sourceMappingURL=sdk-loader.js.map

package/dist/src/cli/autopilot.d.ts

@@ -0,0 +1,71 @@
+import { PHASE_REGISTRY, DEFAULT_FULL_PHASES, type PhaseName } from '../core/run-state/phase-registry.ts';
+export type AutopilotMode = 'full';
+export interface AutopilotOptions {
+    cwd?: string;
+    configPath?: string;
+    /** Pipeline mode. v6.2.0 supports `'full'` only (scan → spec → plan →
+     *  implement). Defaults to `'full'` when neither `mode` nor `phases`
+     *  is supplied. */
+    mode?: AutopilotMode;
+    /** Explicit phase list (overrides `mode`). Validated against
+     *  PHASE_REGISTRY before any run dir is created — unknown names exit 1
+     *  with `invalid_config`. */
+    phases?: readonly string[];
+    /** Run-scope budget (USD). When set, every phase passes through the
+     *  shared `BudgetConfig` with `scope: 'run'` so `actualSoFar` accumulates
+     *  across phases. */
+    budgetUSD?: number;
+    /** v6.0.x — engine knob. The orchestrator REJECTS engine-off explicitly
+     *  (per spec "Engine-off"); these fields exist so the dispatcher can pass
+     *  them through and the orchestrator can produce a clear error message. */
+    cliEngine?: boolean;
+    envEngine?: string;
+    /** Test seam — keep stdout banners suppressed. Production callers MUST
+     *  NOT pass this; the dispatcher does not surface a flag for it. */
+    __silent?: boolean;
+}
+export interface AutopilotPhaseSummary {
+    name: string;
+    status: 'success' | 'failed' | 'skipped' | 'not-run';
+    errorCode?: string;
+    errorMessage?: string;
+    costUSD: number;
+    durationMs: number;
+}
+export interface AutopilotResult {
+    runId: string | null;
+    runDir: string | null;
+    exitCode: number;
+    errorCode?: string;
+    errorMessage?: string;
+    phases: AutopilotPhaseSummary[];
+    totalCostUSD: number;
+    durationMs: number;
+}
+export declare function runAutopilot(options?: AutopilotOptions): Promise<AutopilotResult>;
+export interface AutopilotJsonOptions extends AutopilotOptions {
+    /** Test seam — install process-level uncaughtException / unhandledRejection
+     *  handlers that emit a fallback envelope if the orchestrator throws past
+     *  our try/catch. Default: true (production behavior). Tests pass false to
+     *  avoid leaking handlers across the suite. */
+    __testInstallProcessHandlers?: boolean;
+    /** Test seam — when set, the orchestrator throws AFTER the success
+     *  envelope is written. Used to verify the single-write latch suppresses
+     *  the uncaughtException handler's fallback envelope. Production code
+     *  never sets this. */
+    __testThrowAfterEnvelope?: () => never;
+}
+/** v6.2.2 entrypoint for `claude-autopilot autopilot --json`.
+ *
+ *  Wraps `runAutopilot` (which already handles pre-run failures inline by
+ *  returning an `AutopilotResult` with `runId: null` + populated
+ *  `errorCode` / `errorMessage`) and emits exactly one envelope on stdout.
+ *  Process-level fatal handlers (codex WARNING #2) catch async failures
+ *  that would otherwise bypass our try/catch.
+ *
+ *  Returns the exit code the dispatcher should propagate via
+ *  `process.exit`. */
+export declare function runAutopilotWithJsonEnvelope(options?: AutopilotJsonOptions): Promise<number>;
+export { PHASE_REGISTRY, DEFAULT_FULL_PHASES };
+export type { PhaseName };
+//# sourceMappingURL=autopilot.d.ts.map