@delegance/claude-autopilot 5.0.0 → 5.0.2

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

@@ -0,0 +1,9 @@
+export interface PrCommandOptions {
+    cwd?: string;
+    configPath?: string;
+    prNumber?: string;
+    noPostComments?: boolean;
+    noInlineComments?: boolean;
+}
+export declare function runPr(options?: PrCommandOptions): Promise<number>;
+//# sourceMappingURL=pr.d.ts.map

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

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+export interface DoctorResult {
+    blockers: number;
+    warnings: number;
+}
+export declare function findMissingSuperpowersSkills(): string[];
+export declare function runDoctor(): Promise<DoctorResult>;
+//# sourceMappingURL=preflight.d.ts.map

package/dist/src/cli/preflight.js

@@ -4,6 +4,7 @@ import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runSafe } from "../core/shell.js";
 import { detectLLMKey, loadEnvFile, LLM_KEY_NAMES } from "../core/detect/llm-key.js";
+import { findPackageRoot } from "./_pkg-root.js";
 const PASS = '\x1b[32m✓\x1b[0m';
 const FAIL = '\x1b[31m✗\x1b[0m';
 const WARN = '\x1b[33m!\x1b[0m';
@@ -95,15 +96,27 @@ export async function runDoctor() {
         result: nodeMajor >= 22 ? 'pass' : 'fail',
         message: nodeMajor < 22 ? `Node 22+ required — current: ${nodeVersion}. Install via nvm: nvm install 22` : undefined,
     });
-    // 2. tsx available
+    // 2. tsx available — checked in three places, in order:
+    //   a) consumer project: <cwd>/node_modules/.bin/tsx
+    //   b) this package's own bundled tsx (covers global installs — the package
+    //      ships its own node_modules; bin/_launcher.js uses the same lookup)
+    //   c) PATH fallback
+    // Previous version only checked (a) + (c), which false-positive-failed every
+    // global install since (b) is where tsx actually lives there.
+    const pkgRoot = findPackageRoot(import.meta.url);
+    const ownTsx = pkgRoot ? path.join(pkgRoot, 'node_modules', '.bin', 'tsx') : null;
     const localTsx = path.join(process.cwd(), 'node_modules', '.bin', 'tsx');
     const tsxVersion = fs.existsSync(localTsx)
         ? runSafe(localTsx, ['--version'])
-        : runSafe('tsx', ['--version']);
+        : ownTsx && fs.existsSync(ownTsx)
+            ? runSafe(ownTsx, ['--version'])
+            : runSafe('tsx', ['--version']);
     checks.push({
         name: 'tsx available',
         result: tsxVersion ? 'pass' : 'fail',
-        message: !tsxVersion ? 'tsx not found — run: npm install @delegance/claude-autopilot@alpha (includes tsx for dev builds)' : undefined,
+        message: !tsxVersion
+            ? 'tsx not found — reinstall: npm install -g @delegance/claude-autopilot@latest'
+            : undefined,
     });
     // 3. gh CLI authenticated
     const ghAuth = runSafe('gh', ['auth', 'status']);
@@ -190,7 +203,7 @@ export async function runDoctor() {
     }
     console.log('');
     if (blockers > 0) {
-        console.log(`\x1b[31m[doctor] ${blockers} blocker(s) — fix before running npx guardrail run\x1b[0m\n`);
+        console.log(`\x1b[31m[doctor] ${blockers} blocker(s) — fix before running claude-autopilot run\x1b[0m\n`);
     }
     else if (warnings > 0) {
         console.log(`\x1b[33m[doctor] ${warnings} warning(s) — pipeline will run but some steps may be skipped\x1b[0m\n`);

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

@@ -0,0 +1,7 @@
+export interface ReportCommandOptions {
+    cwd?: string;
+    output?: string;
+    trend?: boolean;
+}
+export declare function runReport(options?: ReportCommandOptions): Promise<number>;
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+export interface RunCommandOptions {
+    cwd?: string;
+    configPath?: string;
+    base?: string;
+    files?: string[];
+    dryRun?: boolean;
+    diff?: boolean;
+    delta?: boolean;
+    newOnly?: boolean;
+    failOn?: 'critical' | 'warning' | 'note' | 'none';
+    inlineComments?: boolean;
+    format?: 'text' | 'sarif' | 'junit';
+    outputPath?: string;
+    postComments?: boolean;
+    skipReview?: boolean;
+}
+/**
+ * Returns an exit code (0 = pass/warn, 1 = fail/error).
+ * Never calls process.exit directly — caller decides when to exit.
+ */
+export declare function runCommand(options?: RunCommandOptions): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

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

@@ -0,0 +1,11 @@
+export interface ScanCommandOptions {
+    cwd?: string;
+    configPath?: string;
+    targets?: string[];
+    all?: boolean;
+    ask?: string;
+    focus?: 'security' | 'logic' | 'performance' | 'brand' | 'all';
+    dryRun?: boolean;
+}
+export declare function runScan(options?: ScanCommandOptions): Promise<number>;
+//# sourceMappingURL=scan.d.ts.map

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

@@ -0,0 +1,9 @@
+export type ProfileName = 'security-strict' | 'team' | 'solo';
+export interface SetupOptions {
+    cwd?: string;
+    force?: boolean;
+    skipHook?: boolean;
+    profile?: ProfileName;
+}
+export declare function runSetup(options?: SetupOptions): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map

package/dist/src/cli/test-gen.d.ts

@@ -0,0 +1,10 @@
+export interface TestGenOptions {
+    cwd?: string;
+    configPath?: string;
+    targets?: string[];
+    base?: string;
+    dryRun?: boolean;
+    verify?: boolean;
+}
+export declare function runTestGen(options?: TestGenOptions): Promise<number>;
+//# sourceMappingURL=test-gen.d.ts.map

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

@@ -0,0 +1,5 @@
+export interface TriageCommandOptions {
+    cwd?: string;
+}
+export declare function runTriage(subcommand: string | undefined, rest: string[], options?: TriageCommandOptions): Promise<number>;
+//# sourceMappingURL=triage.d.ts.map

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

@@ -0,0 +1,18 @@
+export declare const IGNORED_PATTERNS: readonly RegExp[];
+export declare function isIgnored(p: string): boolean;
+/**
+ * Pure debounce accumulator — returned functions are the testable core of watch logic.
+ * schedule(file) → adds file, starts/resets timer; when debounce fires, calls flush(batch).
+ * onSchedule (optional) is called on every schedule() with the file and current queue size.
+ */
+export declare function makeDebouncer(flushFn: (batch: string[]) => void, debounceMs: number, onSchedule?: (file: string, queueSize: number) => void): {
+    schedule: (file: string) => void;
+    pending: () => string[];
+};
+export interface WatchOptions {
+    cwd?: string;
+    configPath?: string;
+    debounceMs?: number;
+}
+export declare function runWatch(options?: WatchOptions): Promise<void>;
+//# sourceMappingURL=watch.d.ts.map

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

@@ -0,0 +1,5 @@
+export declare function runWorker(sub: string | undefined, options?: {
+    cwd?: string;
+    configPath?: string;
+}): Promise<number>;
+//# sourceMappingURL=worker.d.ts.map

package/dist/src/core/cache/cached-engine.d.ts

@@ -0,0 +1,8 @@
+import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
+import { type ReviewCacheOptions } from './review-cache.ts';
+/**
+ * Wraps any ReviewEngine with file-based response caching.
+ * Cache key = SHA-256(adapterName + model + content).
+ */
+export declare function withCache(engine: ReviewEngine, options?: ReviewCacheOptions): ReviewEngine;
+//# sourceMappingURL=cached-engine.d.ts.map

package/dist/src/core/cache/review-cache.d.ts

@@ -0,0 +1,21 @@
+import type { ReviewOutput } from '../../adapters/review-engine/types.ts';
+export interface CacheEntry {
+    key: string;
+    output: ReviewOutput;
+    createdAt: string;
+    expiresAt: string;
+}
+export interface ReviewCacheOptions {
+    cacheDir?: string;
+    ttlMs?: number;
+}
+export declare class ReviewCache {
+    private readonly cacheDir;
+    private readonly ttlMs;
+    constructor(options?: ReviewCacheOptions);
+    static keyFor(adapterName: string, model: string, content: string): string;
+    get(key: string): Promise<ReviewOutput | undefined>;
+    set(key: string, output: ReviewOutput): Promise<void>;
+    private entryPath;
+}
+//# sourceMappingURL=review-cache.d.ts.map

package/dist/src/core/chunking/index.d.ts

@@ -0,0 +1,18 @@
+import type { ReviewEngine, ReviewInput } from '../../adapters/review-engine/types.ts';
+import type { GuardrailConfig } from '../config/types.ts';
+export interface ReviewChunk {
+    content: string;
+    kind: ReviewInput['kind'];
+    files: string[];
+}
+export interface BuildChunksInput {
+    touchedFiles: string[];
+    strategy: 'auto' | 'single-pass' | 'file-level' | 'diff' | 'auto-diff';
+    chunking?: GuardrailConfig['chunking'];
+    engine: ReviewEngine;
+    cwd?: string;
+    protectedPaths?: string[];
+    base?: string;
+}
+export declare function buildReviewChunks(input: BuildChunksInput): Promise<ReviewChunk[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/core/chunking/risk-ranker.d.ts

@@ -0,0 +1,10 @@
+interface RankOptions {
+    protectedPaths?: string[];
+}
+/**
+ * Returns files sorted highest-risk first so LLM sees the most sensitive code
+ * at the start of its context window.
+ */
+export declare function rankByRisk(files: string[], options?: RankOptions): string[];
+export {};
+//# sourceMappingURL=risk-ranker.d.ts.map

package/dist/src/core/config/loader.d.ts

@@ -0,0 +1,3 @@
+import type { GuardrailConfig } from './types.ts';
+export declare function loadConfig(path: string): Promise<GuardrailConfig>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/src/core/config/preset-resolver.d.ts

@@ -0,0 +1,9 @@
+import type { GuardrailConfig } from './types.ts';
+export interface ResolvedPreset {
+    name: string;
+    config: GuardrailConfig;
+    stack: string;
+}
+export declare function resolvePreset(name: string): Promise<ResolvedPreset>;
+export declare function mergeConfigs(preset: GuardrailConfig, user: GuardrailConfig): GuardrailConfig;
+//# sourceMappingURL=preset-resolver.d.ts.map

package/dist/src/core/config/schema.d.ts

@@ -0,0 +1,342 @@
+export declare const GUARDRAIL_CONFIG_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly type: "object";
+    readonly required: readonly ["configVersion"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly configVersion: {
+            readonly const: 1;
+        };
+        readonly preset: {
+            readonly type: "string";
+        };
+        readonly reviewEngine: {
+            readonly $ref: "#/definitions/adapterRef";
+        };
+        readonly vcsHost: {
+            readonly $ref: "#/definitions/adapterRef";
+        };
+        readonly migrationRunner: {
+            readonly $ref: "#/definitions/adapterRef";
+        };
+        readonly reviewBot: {
+            readonly $ref: "#/definitions/adapterRef";
+        };
+        readonly adapterAllowlist: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly protectedPaths: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly staticRules: {
+            readonly type: "array";
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "object";
+                    readonly required: readonly ["adapter"];
+                    readonly properties: {
+                        readonly adapter: {
+                            readonly type: "string";
+                        };
+                        readonly options: {
+                            readonly type: "object";
+                        };
+                    };
+                }];
+            };
+        };
+        readonly staticRulesParallel: {
+            readonly type: "boolean";
+        };
+        readonly stack: {
+            readonly type: "string";
+        };
+        readonly testCommand: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly thresholds: {
+            readonly type: "object";
+            readonly properties: {
+                readonly bugbotAutoFix: {
+                    readonly type: "number";
+                };
+                readonly bugbotProposePatch: {
+                    readonly type: "number";
+                };
+                readonly maxValidateRetries: {
+                    readonly type: "number";
+                };
+                readonly maxCodexRetries: {
+                    readonly type: "number";
+                };
+                readonly maxBugbotRounds: {
+                    readonly type: "number";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly ignore: {
+            readonly type: "array";
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "object";
+                    readonly required: readonly ["path"];
+                    readonly properties: {
+                        readonly rule: {
+                            readonly type: "string";
+                        };
+                        readonly path: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+            };
+        };
+        readonly reviewStrategy: {
+            readonly enum: readonly ["auto", "single-pass", "file-level", "diff", "auto-diff"];
+        };
+        readonly chunking: {
+            readonly type: "object";
+            readonly properties: {
+                readonly smallTierMaxTokens: {
+                    readonly type: "number";
+                };
+                readonly partialReviewTokens: {
+                    readonly type: "number";
+                };
+                readonly perFileMaxTokens: {
+                    readonly type: "number";
+                };
+                readonly parallelism: {
+                    readonly type: "number";
+                };
+                readonly rateLimitBackoff: {
+                    readonly enum: readonly ["exp", "linear", "none"];
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly policy: {
+            readonly type: "object";
+            readonly properties: {
+                readonly failOn: {
+                    readonly enum: readonly ["critical", "warning", "note", "none"];
+                };
+                readonly newOnly: {
+                    readonly type: "boolean";
+                };
+                readonly baselinePath: {
+                    readonly type: "string";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly pipeline: {
+            readonly type: "object";
+            readonly properties: {
+                readonly runReviewOnStaticFail: {
+                    readonly type: "boolean";
+                };
+                readonly runReviewOnTestFail: {
+                    readonly type: "boolean";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly cost: {
+            readonly type: "object";
+            readonly properties: {
+                readonly maxPerRun: {
+                    readonly type: "number";
+                };
+                readonly estimateBeforeRun: {
+                    readonly type: "boolean";
+                };
+                readonly pricing: {
+                    readonly type: "object";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly brand: {
+            readonly type: "object";
+            readonly properties: {
+                readonly colorsFrom: {
+                    readonly type: "string";
+                };
+                readonly colors: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly fonts: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly componentLibrary: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly tokens: {
+                                readonly type: "string";
+                            };
+                            readonly guide: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    }];
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly 'schema-alignment': {
+            readonly type: "object";
+            readonly properties: {
+                readonly enabled: {
+                    readonly type: "boolean";
+                };
+                readonly migrationGlobs: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly layerRoots: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly types: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly minItems: 1;
+                        };
+                        readonly api: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly minItems: 1;
+                        };
+                        readonly ui: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly minItems: 1;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+                readonly llmCheck: {
+                    readonly type: "boolean";
+                };
+                readonly severity: {
+                    readonly enum: readonly ["warning", "error"];
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly cache: {
+            readonly type: "object";
+        };
+        readonly persistence: {
+            readonly type: "object";
+        };
+        readonly concurrency: {
+            readonly type: "object";
+        };
+        readonly council: {
+            readonly type: "object";
+            readonly required: readonly ["models", "synthesizer"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly models: {
+                    readonly type: "array";
+                    readonly minItems: 2;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["adapter", "model", "label"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly adapter: {
+                                readonly type: "string";
+                            };
+                            readonly model: {
+                                readonly type: "string";
+                            };
+                            readonly label: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+                readonly synthesizer: {
+                    readonly type: "object";
+                    readonly required: readonly ["adapter", "model", "label"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly adapter: {
+                            readonly type: "string";
+                        };
+                        readonly model: {
+                            readonly type: "string";
+                        };
+                        readonly label: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly timeout_ms: {
+                    readonly type: "number";
+                };
+                readonly min_successful_responses: {
+                    readonly type: "number";
+                };
+                readonly parallel_input_max_tokens: {
+                    readonly type: "number";
+                };
+                readonly synthesis_input_max_tokens: {
+                    readonly type: "number";
+                };
+            };
+        };
+    };
+    readonly definitions: {
+        readonly adapterRef: {
+            readonly oneOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "object";
+                readonly required: readonly ["adapter"];
+                readonly properties: {
+                    readonly adapter: {
+                        readonly type: "string";
+                    };
+                    readonly options: {
+                        readonly type: "object";
+                    };
+                };
+            }];
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map