auto-mode 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -1,9 +1,3 @@
-//#region src/budget/types.d.ts
-interface DenialBudget {
-  readonly consecutive: number;
-  readonly perSession: number;
-}
-//#endregion
 //#region src/request/types.d.ts
 interface UserTask {
   readonly text: string;
@@ -45,6 +39,51 @@ interface DecisionRule {
   readonly source: 'shipped' | 'replacement' | 'configured';
   readonly text: string;
 }
+type DecisionChoice = 'allow' | 'block';
+type RecordedDecisionChoice = DecisionChoice | 'ask';
+interface DecisionQuestion<Choice extends string = DecisionChoice> {
+  readonly type: 'choice';
+  readonly instructions: string;
+  readonly criteria: Readonly<Record<Choice, string>>;
+}
+interface DecisionInput<Choice extends string = DecisionChoice> {
+  readonly state: {
+    readonly policy: string;
+    readonly answerGuidance: string;
+    readonly rulesSource: 'shipped' | 'replacement';
+    readonly configuredRules: ClaudeRules;
+    readonly lastUserMessage: string | null;
+    readonly repositoryContext?: RepositoryContext;
+    readonly mcpServers?: readonly MCPServerFact[];
+    readonly taskContext?: DecisionContext;
+    readonly action: {
+      readonly tool: string;
+      readonly cwd: string;
+      readonly input: Readonly<Record<string, unknown>>;
+    };
+  };
+  readonly questions: Readonly<Record<string, DecisionQuestion<Choice>>>;
+}
+interface DecisionRequest extends DecisionInput {
+  readonly rules: Readonly<Record<string, DecisionRule>>;
+}
+interface RepositoryContext {
+  readonly cwd: string;
+  readonly branch: string | null;
+  readonly defaultBranch: string | null;
+  readonly remotes?: readonly RepositoryRemote[] | undefined;
+  readonly taskScope?: TaskScopeSummary | undefined;
+}
+interface MCPServerFact {
+  readonly name: string;
+  readonly scope: 'user' | 'local' | 'project';
+  readonly transport: 'stdio' | 'http' | 'sse' | 'ws';
+  readonly host: string | null;
+}
+interface RepositoryRemote {
+  readonly name: string;
+  readonly url: string;
+}
 interface TaskScopeSummary {
   readonly worktrees: readonly string[];
   readonly branches: readonly string[];
@@ -53,12 +92,18 @@ interface TaskScopeSummary {
     readonly number: number;
   }[];
 }
-interface DecisionAnswer {
+interface DecisionAnswer<Choice extends string = DecisionChoice> {
   readonly type: 'choice';
-  readonly choice: 'allow' | 'block' | 'ask';
-  readonly probabilities: Readonly<Record<'allow' | 'block' | 'ask', number>>;
+  readonly choice: Choice;
+  readonly probabilities: Readonly<Record<Choice, number>>;
   readonly confidence: number;
 }
+interface DecisionResult<Choice extends string = DecisionChoice> {
+  readonly model: string;
+  readonly answers: Readonly<Record<string, DecisionAnswer<Choice>>>;
+  readonly inputTokens: number;
+  readonly requestBytes: number;
+}
 type DecisionFailureReason = 'request-too-large' | 'aborted' | 'network' | 'http-status' | 'invalid-response';
 interface DecisionDiagnostics {
   readonly status: 'allow' | 'deny' | 'failure' | 'timeout' | 'cancelled';
@@ -68,22 +113,96 @@ interface DecisionDiagnostics {
   readonly failureReason: DecisionFailureReason | null;
   readonly requestBytes: number | null;
   readonly elapsedMs: number;
-  readonly minConfidence: number;
+  readonly blockThreshold: number;
   readonly contributors: readonly {
     readonly rule: string;
     readonly source: DecisionRule['source'];
     readonly tier: DecisionRule['tier'];
     readonly choice: DecisionAnswer['choice'];
     readonly confidence: number;
-    readonly probability: number;
+    readonly blockProbability: number;
   }[];
 }
 //#endregion
 //#region src/config/types.d.ts
+interface OutputStream {
+  readonly write: (text: string) => unknown;
+}
+interface HostEnvironment {
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly home: string;
+  readonly scratchPaths?: readonly string[] | undefined;
+}
+interface ClaudeRules {
+  readonly environment: readonly string[];
+  readonly allow: readonly string[];
+  readonly soft_deny: readonly string[];
+  readonly hard_deny: readonly string[];
+}
+interface ClaudeSettings {
+  readonly rules: ClaudeRules;
+  readonly userSettings: unknown;
+}
 interface EvaluationOptions {
+  readonly claudeSettings?: ClaudeSettings | undefined;
   readonly deadlineAt?: number | undefined;
   readonly signal?: Readonly<AbortSignal> | undefined;
   readonly taskScope?: TaskScopeSummary | undefined;
+  readonly host?: Readonly<HostEnvironment> | undefined;
+  readonly now?: (() => number) | undefined;
+  readonly timeout?: ((ms: number) => AbortSignal) | undefined;
+}
+//#endregion
+//#region src/containment/collect-scope-findings.d.ts
+interface ScopeRemote {
+  readonly name: string;
+  readonly url: string;
+}
+interface OwnedPullRequest {
+  readonly number: number;
+  readonly repository: string;
+}
+interface OwnedScope {
+  readonly home: string;
+  readonly worktrees: readonly string[];
+  readonly branches: readonly string[];
+  readonly currentBranch: string | null;
+  readonly remotes: readonly ScopeRemote[];
+  readonly pullRequests: readonly OwnedPullRequest[];
+  readonly pathGlobs: readonly string[];
+}
+interface ScopeFinding {
+  readonly kind: 'path' | 'branch' | 'remote-write' | 'credential' | 'prune';
+  readonly target: string;
+}
+//#endregion
+//#region src/scope/find-checkout.d.ts
+interface Checkout {
+  readonly worktree: string;
+  readonly commonDir: string;
+}
+//#endregion
+//#region src/bypass/classify-edit.d.ts
+type EditClassification = {
+  readonly kind: 'bypass';
+  readonly target: string;
+} | {
+  readonly kind: 'jev';
+  readonly reason: string;
+};
+//#endregion
+//#region src/bypass/try-classify-edit.d.ts
+interface EditFileReader {
+  readonly resolveEditTarget: (path: string) => Promise<string | null>;
+  readonly findCheckout: (directory: string, env: HostEnvironment['env']) => Promise<Checkout | null>;
+  readonly readFile: (path: string) => Promise<string>;
+}
+export declare function tryClassifyEdit(request: Readonly<ActionRequest>, scope: Readonly<OwnedScope>, host: Readonly<HostEnvironment>, files?: Readonly<EditFileReader>): Promise<EditClassification | null>;
+//#endregion
+//#region src/budget/types.d.ts
+interface DenialBudget {
+  readonly consecutive: number;
+  readonly perSession: number;
 }
 //#endregion
 //#region src/config/presets.d.ts
@@ -114,13 +233,13 @@ interface Config {
   readonly rulesPath?: string | undefined;
   readonly onFailure: 'defer' | 'deny';
   readonly claudeSettingsPath?: string | null | undefined;
-  readonly minConfidence?: number | undefined;
+  readonly blockThreshold?: number | undefined;
   readonly denialBudget?: DenialBudget;
   readonly warnings?: readonly string[];
 }
 export declare const DEFAULT_CONFIG: Config;
-export declare function resolveConfigPath(): string;
-export declare function loadConfig(path?: string): Promise<Config>;
+export declare function resolveConfigPath(host?: Readonly<HostEnvironment>): string;
+export declare function loadConfig(configPath?: string, host?: Readonly<HostEnvironment>): Promise<Config>;
 export declare function resolveApiKey(provider: ProviderConfig, options?: EvaluationOptions): Promise<string | null>;
 //#endregion
 //#region src/classify-action.d.ts
@@ -135,9 +254,24 @@ interface ActionOutcome {
 }
 interface ClassifyOptions extends EvaluationOptions {
   readonly localOnly?: boolean;
+  readonly stderr?: Readonly<OutputStream> | undefined;
 }
 export declare function classifyAction(request: ActionRequest, config: Config, options?: ClassifyOptions): Promise<ActionOutcome>;
 //#endregion
+//#region src/config/load-claude-rules.d.ts
+export declare function loadClaudeRules(path: string | null | undefined, host: Readonly<HostEnvironment>): Promise<ClaudeRules>;
+//#endregion
+//#region src/containment/check-containment.d.ts
+interface ContainmentDeny {
+  readonly rule: string;
+  readonly reason: string;
+  readonly findings: readonly ScopeFinding[];
+}
+export declare function checkContainment(request: Readonly<ActionRequest>, scope: Readonly<OwnedScope>, scratchPaths?: readonly string[]): ContainmentDeny | null;
+//#endregion
+//#region src/model/build-decision-request.d.ts
+export declare function buildDecisionRequest(payload: ActionRequest, policy: string, configuredRules: ClaudeRules, lastUserMessage: string | null, rulesSource?: 'shipped' | 'replacement', repositoryContext?: RepositoryContext | null, mcpServers?: readonly MCPServerFact[]): DecisionRequest;
+//#endregion
 //#region src/model/classify-with-model.d.ts
 interface ModelOutcome {
   readonly verdict: Verdict | null;
@@ -147,9 +281,26 @@ interface ModelOutcome {
 }
 export declare function classifyWithModel(payload: ActionRequest, config: Config, options?: EvaluationOptions): Promise<ModelOutcome>;
 //#endregion
+//#region src/model/decision-request-error.d.ts
+export declare class DecisionRequestError extends Error {
+  readonly reason: DecisionFailureReason;
+  readonly requestBytes: number;
+  constructor(reason: DecisionFailureReason, requestBytes: number, message: string, options?: Readonly<ErrorOptions>);
+}
+//#endregion
 //#region src/model/parse-verdict.d.ts
 export declare function parseModelVerdict(text: string): Verdict;
 //#endregion
+//#region src/model/send-decision.d.ts
+interface SendOptions {
+  readonly fetch?: (url: string, init: Readonly<RequestInit>) => Promise<Response>;
+}
+interface SendDecisionOptions<Choice extends string> extends SendOptions {
+  readonly choices: readonly [Choice, ...Choice[]];
+}
+export declare function sendDecision(provider: ProviderConfig, apiKey: string, request: DecisionInput, signal: Readonly<AbortSignal>, options?: SendOptions): Promise<DecisionResult>;
+export declare function sendDecision<Choice extends string>(provider: ProviderConfig, apiKey: string, request: DecisionInput<Choice>, signal: Readonly<AbortSignal>, options: SendDecisionOptions<Choice>): Promise<DecisionResult<Choice>>;
+//#endregion
 //#region src/policy/load-policy.d.ts
 interface PolicyPaths {
   readonly classifierPath?: string | undefined;
@@ -172,4 +323,48 @@ type LocalVerdict = {
 };
 export declare function classifyLocally(payload: ActionRequest): LocalVerdict;
 //#endregion
-export type { ActionOutcome, ActionRequest, ClassifyOptions, Config, DecisionContext, LocalVerdict, ModelOutcome, PolicyPaths, ProviderConfig, ScopeSource, Verdict };
+//#region src/scope/types.d.ts
+interface ScopePullRequest {
+  readonly number: number;
+  readonly head: string;
+  readonly repository: string;
+}
+interface ScopeFacts {
+  readonly worktrees: readonly string[];
+  readonly branches: readonly string[];
+  readonly pullRequests: readonly ScopePullRequest[];
+  readonly pathGlobs: readonly string[];
+}
+type ScopeEvent = {
+  readonly kind: 'worktree';
+  readonly path: string;
+} | {
+  readonly kind: 'branch';
+  readonly name: string;
+  readonly directory: string;
+} | {
+  readonly kind: 'pull-request';
+  readonly directory: string;
+  readonly head: string | null;
+};
+interface SessionBranch {
+  readonly name: string;
+  readonly commonDir: string;
+}
+interface SessionScope {
+  readonly worktrees: readonly string[];
+  readonly branches: readonly SessionBranch[];
+  readonly pullRequests: readonly ScopePullRequest[];
+}
+//#endregion
+//#region src/scope/build-task-scope.d.ts
+interface TaskScopeInput {
+  readonly home: string;
+  readonly currentBranch: string | null;
+  readonly defaultBranch: string | null;
+  readonly remotes: readonly ScopeRemote[];
+  readonly facts: readonly ScopeFacts[];
+}
+export declare function buildTaskScope(input: Readonly<TaskScopeInput>): OwnedScope;
+//#endregion
+export type { ActionOutcome, ActionRequest, ClassifyOptions, ClaudeRules, Config, ContainmentDeny, DecisionContext, DecisionRequest, DecisionResult, DecisionRule, EditClassification, LocalVerdict, ModelOutcome, OwnedScope, PolicyPaths, ProviderConfig, RecordedDecisionChoice, RepositoryContext, ScopeEvent, ScopeSource, SessionScope, Verdict };

package/dist/index.js

@@ -1,2 +1,7 @@
-import { C as resolveConfigPath, S as resolveApiKey, d as parseModelVerdict, l as classifyLocally, m as loadPolicy, n as parseActionRequest, r as classifyAction, t as renderVerdict, u as classifyWithModel, v as DEFAULT_CONFIG, w as PRESETS, x as loadConfig } from "./render-verdict-QLyj-g7d.js";
-export { DEFAULT_CONFIG, PRESETS, classifyAction, classifyLocally, classifyWithModel, loadConfig, loadPolicy, parseActionRequest, parseModelVerdict, renderVerdict, resolveApiKey, resolveConfigPath };
+import { A as resolveConfigPath, M as PRESETS, O as loadConfig, S as tryClassifyEdit, T as DEFAULT_CONFIG, _ as checkContainment, c as classifyLocally, d as sendDecision, g as loadPolicy, h as buildDecisionRequest, k as resolveApiKey, l as classifyWithModel, m as DecisionRequestError, n as parseActionRequest, r as classifyAction, s as buildTaskScope, t as renderVerdict, u as parseModelVerdict, x as loadClaudeSettings } from "./render-verdict-u3_ftSEp.js";
+//#region src/config/load-claude-rules.ts
+async function loadClaudeRules(path, host) {
+	return (await loadClaudeSettings(path, host)).rules;
+}
+//#endregion
+export { DEFAULT_CONFIG, DecisionRequestError, PRESETS, buildDecisionRequest, buildTaskScope, checkContainment, classifyAction, classifyLocally, classifyWithModel, loadClaudeRules, loadConfig, loadPolicy, parseActionRequest, parseModelVerdict, renderVerdict, resolveApiKey, resolveConfigPath, sendDecision, tryClassifyEdit };