@sentry/warden 0.0.0 → 0.1.0

package/dist/action/config/schema.d.ts

@@ -0,0 +1,318 @@
+import { z } from 'zod';
+export declare const ToolNameSchema: z.ZodEnum<{
+    Read: "Read";
+    Write: "Write";
+    Edit: "Edit";
+    Bash: "Bash";
+    Glob: "Glob";
+    Grep: "Grep";
+    WebFetch: "WebFetch";
+    WebSearch: "WebSearch";
+}>;
+export type ToolName = z.infer<typeof ToolNameSchema>;
+export declare const ToolConfigSchema: z.ZodObject<{
+    allowed: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Read: "Read";
+        Write: "Write";
+        Edit: "Edit";
+        Bash: "Bash";
+        Glob: "Glob";
+        Grep: "Grep";
+        WebFetch: "WebFetch";
+        WebSearch: "WebSearch";
+    }>>>;
+    denied: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Read: "Read";
+        Write: "Write";
+        Edit: "Edit";
+        Bash: "Bash";
+        Glob: "Glob";
+        Grep: "Grep";
+        WebFetch: "WebFetch";
+        WebSearch: "WebSearch";
+    }>>>;
+}, z.core.$strip>;
+export type ToolConfig = z.infer<typeof ToolConfigSchema>;
+export declare const SkillDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    prompt: z.ZodString;
+    tools: z.ZodOptional<z.ZodObject<{
+        allowed: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            Read: "Read";
+            Write: "Write";
+            Edit: "Edit";
+            Bash: "Bash";
+            Glob: "Glob";
+            Grep: "Grep";
+            WebFetch: "WebFetch";
+            WebSearch: "WebSearch";
+        }>>>;
+        denied: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            Read: "Read";
+            Write: "Write";
+            Edit: "Edit";
+            Bash: "Bash";
+            Glob: "Glob";
+            Grep: "Grep";
+            WebFetch: "WebFetch";
+            WebSearch: "WebSearch";
+        }>>>;
+    }, z.core.$strip>>;
+    outputSchema: z.ZodOptional<z.ZodString>;
+    rootDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;
+export declare const PathFilterSchema: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PathFilter = z.infer<typeof PathFilterSchema>;
+export declare const OutputConfigSchema: z.ZodObject<{
+    failOn: z.ZodOptional<z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+        info: "info";
+        off: "off";
+    }>>;
+    commentOn: z.ZodOptional<z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+        info: "info";
+        off: "off";
+    }>>;
+    maxFindings: z.ZodOptional<z.ZodNumber>;
+    commentOnSuccess: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OutputConfig = z.infer<typeof OutputConfigSchema>;
+export declare const ScheduleConfigSchema: z.ZodObject<{
+    issueTitle: z.ZodOptional<z.ZodString>;
+    createFixPR: z.ZodDefault<z.ZodBoolean>;
+    fixBranchPrefix: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type ScheduleConfig = z.infer<typeof ScheduleConfigSchema>;
+export declare const TriggerSchema: z.ZodObject<{
+    name: z.ZodString;
+    event: z.ZodEnum<{
+        pull_request: "pull_request";
+        issues: "issues";
+        issue_comment: "issue_comment";
+        schedule: "schedule";
+    }>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill: z.ZodString;
+    remote: z.ZodOptional<z.ZodString>;
+    filters: z.ZodOptional<z.ZodObject<{
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    output: z.ZodOptional<z.ZodObject<{
+        failOn: z.ZodOptional<z.ZodEnum<{
+            critical: "critical";
+            high: "high";
+            medium: "medium";
+            low: "low";
+            info: "info";
+            off: "off";
+        }>>;
+        commentOn: z.ZodOptional<z.ZodEnum<{
+            critical: "critical";
+            high: "high";
+            medium: "medium";
+            low: "low";
+            info: "info";
+            off: "off";
+        }>>;
+        maxFindings: z.ZodOptional<z.ZodNumber>;
+        commentOnSuccess: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodString>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    schedule: z.ZodOptional<z.ZodObject<{
+        issueTitle: z.ZodOptional<z.ZodString>;
+        createFixPR: z.ZodDefault<z.ZodBoolean>;
+        fixBranchPrefix: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Trigger = z.infer<typeof TriggerSchema>;
+export declare const RunnerConfigSchema: z.ZodObject<{
+    concurrency: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RunnerConfig = z.infer<typeof RunnerConfigSchema>;
+export declare const FilePatternSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        "per-hunk": "per-hunk";
+        "whole-file": "whole-file";
+        skip: "skip";
+    }>>;
+}, z.core.$strip>;
+export type FilePattern = z.infer<typeof FilePatternSchema>;
+export declare const CoalesceConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxGapLines: z.ZodDefault<z.ZodNumber>;
+    maxChunkSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type CoalesceConfig = z.infer<typeof CoalesceConfigSchema>;
+export declare const ChunkingConfigSchema: z.ZodObject<{
+    filePatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            "per-hunk": "per-hunk";
+            "whole-file": "whole-file";
+            skip: "skip";
+        }>>;
+    }, z.core.$strip>>>;
+    coalesce: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxGapLines: z.ZodDefault<z.ZodNumber>;
+        maxChunkSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ChunkingConfig = z.infer<typeof ChunkingConfigSchema>;
+export declare const DefaultsSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodObject<{
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    output: z.ZodOptional<z.ZodObject<{
+        failOn: z.ZodOptional<z.ZodEnum<{
+            critical: "critical";
+            high: "high";
+            medium: "medium";
+            low: "low";
+            info: "info";
+            off: "off";
+        }>>;
+        commentOn: z.ZodOptional<z.ZodEnum<{
+            critical: "critical";
+            high: "high";
+            medium: "medium";
+            low: "low";
+            info: "info";
+            off: "off";
+        }>>;
+        maxFindings: z.ZodOptional<z.ZodNumber>;
+        commentOnSuccess: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodString>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    defaultBranch: z.ZodOptional<z.ZodString>;
+    chunking: z.ZodOptional<z.ZodObject<{
+        filePatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            pattern: z.ZodString;
+            mode: z.ZodDefault<z.ZodEnum<{
+                "per-hunk": "per-hunk";
+                "whole-file": "whole-file";
+                skip: "skip";
+            }>>;
+        }, z.core.$strip>>>;
+        coalesce: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxGapLines: z.ZodDefault<z.ZodNumber>;
+            maxChunkSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    batchDelayMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Defaults = z.infer<typeof DefaultsSchema>;
+export declare const WardenConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        filters: z.ZodOptional<z.ZodObject<{
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        output: z.ZodOptional<z.ZodObject<{
+            failOn: z.ZodOptional<z.ZodEnum<{
+                critical: "critical";
+                high: "high";
+                medium: "medium";
+                low: "low";
+                info: "info";
+                off: "off";
+            }>>;
+            commentOn: z.ZodOptional<z.ZodEnum<{
+                critical: "critical";
+                high: "high";
+                medium: "medium";
+                low: "low";
+                info: "info";
+                off: "off";
+            }>>;
+            maxFindings: z.ZodOptional<z.ZodNumber>;
+            commentOnSuccess: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        model: z.ZodOptional<z.ZodString>;
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+        defaultBranch: z.ZodOptional<z.ZodString>;
+        chunking: z.ZodOptional<z.ZodObject<{
+            filePatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                pattern: z.ZodString;
+                mode: z.ZodDefault<z.ZodEnum<{
+                    "per-hunk": "per-hunk";
+                    "whole-file": "whole-file";
+                    skip: "skip";
+                }>>;
+            }, z.core.$strip>>>;
+            coalesce: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                maxGapLines: z.ZodDefault<z.ZodNumber>;
+                maxChunkSize: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        batchDelayMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    triggers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        event: z.ZodEnum<{
+            pull_request: "pull_request";
+            issues: "issues";
+            issue_comment: "issue_comment";
+            schedule: "schedule";
+        }>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skill: z.ZodString;
+        remote: z.ZodOptional<z.ZodString>;
+        filters: z.ZodOptional<z.ZodObject<{
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        output: z.ZodOptional<z.ZodObject<{
+            failOn: z.ZodOptional<z.ZodEnum<{
+                critical: "critical";
+                high: "high";
+                medium: "medium";
+                low: "low";
+                info: "info";
+                off: "off";
+            }>>;
+            commentOn: z.ZodOptional<z.ZodEnum<{
+                critical: "critical";
+                high: "high";
+                medium: "medium";
+                low: "low";
+                info: "info";
+                off: "off";
+            }>>;
+            maxFindings: z.ZodOptional<z.ZodNumber>;
+            commentOnSuccess: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        model: z.ZodOptional<z.ZodString>;
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+        schedule: z.ZodOptional<z.ZodObject<{
+            issueTitle: z.ZodOptional<z.ZodString>;
+            createFixPR: z.ZodDefault<z.ZodBoolean>;
+            fixBranchPrefix: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    runner: z.ZodOptional<z.ZodObject<{
+        concurrency: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WardenConfig = z.infer<typeof WardenConfigSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/action/config/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,cAAc;;;;;;;;;EASzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAGtD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;iBAG3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAG1D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAGpE,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAG1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;iBAM7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,eAAO,MAAM,oBAAoB;;;;iBAO/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGlE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCzB,CAAC;AACF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAGpD,eAAO,MAAM,kBAAkB;;iBAG7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,eAAO,MAAM,iBAAiB;;;;;;;iBAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAG5D,eAAO,MAAM,oBAAoB;;;;iBAO/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGlE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;iBAK/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGlE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAazB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAGtD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/action/config/writer.d.ts

@@ -0,0 +1,11 @@
+import type { Trigger } from './schema.js';
+/**
+ * Generate TOML representation of a trigger.
+ */
+export declare function generateTriggerToml(trigger: Trigger): string;
+/**
+ * Append a trigger to the warden.toml configuration file.
+ * Preserves existing content and formatting by appending to the end.
+ */
+export declare function appendTrigger(configPath: string, trigger: Trigger): void;
+//# sourceMappingURL=writer.d.ts.map

package/dist/action/config/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/config/writer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAsD5D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAiBxE"}

package/dist/action/config/writer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=writer.test.d.ts.map

package/dist/action/config/writer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.test.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/config/writer.test.ts"],"names":[],"mappings":""}

package/dist/action/diff/classify.d.ts

@@ -0,0 +1,29 @@
+/**
+ * File classification for chunking - determines how files should be processed
+ */
+import type { FilePattern } from '../config/schema.js';
+/** Processing mode for a file */
+export type FileMode = 'per-hunk' | 'whole-file' | 'skip';
+/**
+ * Built-in patterns that are always applied before user patterns.
+ * These skip common lock files, minified code, and build artifacts.
+ */
+export declare const BUILTIN_SKIP_PATTERNS: string[];
+/**
+ * Classify a file to determine how it should be processed.
+ *
+ * @param filename - The file path to classify
+ * @param userPatterns - Optional user-defined patterns (can override built-ins)
+ * @returns The processing mode: 'per-hunk', 'whole-file', or 'skip'
+ *
+ * Order of precedence:
+ * 1. User patterns are checked first (higher priority, allows overriding built-ins)
+ * 2. Built-in skip patterns are checked second
+ * 3. Default is 'per-hunk' if no patterns match
+ */
+export declare function classifyFile(filename: string, userPatterns?: FilePattern[]): FileMode;
+/**
+ * Check if a file should be skipped based on classification.
+ */
+export declare function shouldSkipFile(filename: string, userPatterns?: FilePattern[]): boolean;
+//# sourceMappingURL=classify.d.ts.map

package/dist/action/diff/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/classify.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,iCAAiC;AACjC,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,YAAY,GAAG,MAAM,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,UAiCjC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,WAAW,EAAE,GAC3B,QAAQ,CAiBV;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,WAAW,EAAE,GAC3B,OAAO,CAET"}

package/dist/action/diff/classify.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=classify.test.d.ts.map

package/dist/action/diff/classify.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.test.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/classify.test.ts"],"names":[],"mappings":""}

package/dist/action/diff/coalesce.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Hunk coalescing - merges nearby hunks into fewer, larger chunks
+ * to reduce the number of LLM API calls while keeping chunk sizes manageable.
+ */
+import type { DiffHunk } from './parser.js';
+/** Default maximum gap in lines between hunks to merge */
+export declare const DEFAULT_MAX_GAP_LINES = 30;
+/** Default maximum chunk size in characters */
+export declare const DEFAULT_MAX_CHUNK_SIZE = 8000;
+/**
+ * Options for coalescing hunks.
+ */
+export interface CoalesceOptions {
+    /** Max lines gap between hunks to merge (default: 30) */
+    maxGapLines?: number;
+    /** Target max size per chunk in characters (default: 8000) */
+    maxChunkSize?: number;
+}
+/**
+ * Coalesce hunks that are close together into larger chunks.
+ *
+ * This reduces the number of LLM API calls by merging nearby hunks,
+ * while respecting size limits to keep chunks manageable.
+ *
+ * @param hunks - Array of hunks to coalesce
+ * @param options - Coalescing options (maxGapLines, maxChunkSize)
+ * @returns Array of coalesced hunks (may be smaller than input)
+ *
+ * Algorithm:
+ * 1. Sort hunks by start line
+ * 2. For each hunk, check if it can be merged with the previous:
+ *    - Gap between hunks <= maxGapLines
+ *    - Combined size <= maxChunkSize
+ * 3. If both conditions are met, merge; otherwise start a new chunk
+ */
+export declare function coalesceHunks(hunks: DiffHunk[], options?: CoalesceOptions): DiffHunk[];
+/**
+ * Check if coalescing would reduce the number of hunks.
+ * Useful for deciding whether to show coalescing stats.
+ */
+export declare function wouldCoalesceReduce(hunks: DiffHunk[], options?: CoalesceOptions): boolean;
+//# sourceMappingURL=coalesce.d.ts.map

package/dist/action/diff/coalesce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesce.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/coalesce.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,0DAA0D;AAC1D,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC,+CAA+C;AAC/C,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA4CD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,QAAQ,EAAE,EACjB,OAAO,GAAE,eAAoB,GAC5B,QAAQ,EAAE,CAkCZ;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,EAAE,EACjB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAIT"}

package/dist/action/diff/coalesce.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coalesce.test.d.ts.map

package/dist/action/diff/coalesce.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesce.test.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/coalesce.test.ts"],"names":[],"mappings":""}

package/dist/action/diff/context.d.ts

@@ -0,0 +1,30 @@
+import type { DiffHunk, ParsedDiff } from './parser.js';
+/** Clear the file cache (useful for testing or long-running processes) */
+export declare function clearFileCache(): void;
+export interface HunkWithContext {
+    /** File path */
+    filename: string;
+    /** The hunk being analyzed */
+    hunk: DiffHunk;
+    /** Lines before the hunk (from actual file) */
+    contextBefore: string[];
+    /** Lines after the hunk (from actual file) */
+    contextAfter: string[];
+    /** Start line of contextBefore */
+    contextStartLine: number;
+    /** Detected language from file extension */
+    language: string;
+}
+/**
+ * Expand a hunk with surrounding context from the actual file.
+ */
+export declare function expandHunkContext(repoPath: string, filename: string, hunk: DiffHunk, contextLines?: number): HunkWithContext;
+/**
+ * Expand all hunks in a parsed diff with context.
+ */
+export declare function expandDiffContext(repoPath: string, diff: ParsedDiff, contextLines?: number): HunkWithContext[];
+/**
+ * Format a hunk with context for LLM analysis.
+ */
+export declare function formatHunkForAnalysis(hunkCtx: HunkWithContext): string;
+//# sourceMappingURL=context.d.ts.map

package/dist/action/diff/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAMxD,0EAA0E;AAC1E,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAyBD,MAAM,WAAW,eAAe;IAC9B,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,IAAI,EAAE,QAAQ,CAAC;IACf,+CAA+C;IAC/C,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,8CAA8C;IAC9C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,kCAAkC;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB;AA2DD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,QAAQ,EACd,YAAY,SAAK,GAChB,eAAe,CA0BjB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,YAAY,SAAK,GAChB,eAAe,EAAE,CAInB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAwCtE"}

package/dist/action/diff/context.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.test.d.ts.map

package/dist/action/diff/context.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.test.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/context.test.ts"],"names":[],"mappings":""}

package/dist/action/diff/index.d.ts

@@ -0,0 +1,5 @@
+export * from './parser.js';
+export * from './context.js';
+export * from './classify.js';
+export * from './coalesce.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/action/diff/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}

package/dist/action/diff/parser.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Unified diff parser - extracts hunks from patch strings
+ */
+export interface DiffHunk {
+    /** Original file start line */
+    oldStart: number;
+    /** Original file line count */
+    oldCount: number;
+    /** New file start line */
+    newStart: number;
+    /** New file line count */
+    newCount: number;
+    /** Optional header (function/class name) */
+    header?: string;
+    /** The raw hunk content including the @@ line */
+    content: string;
+    /** Just the changed lines (without @@ header) */
+    lines: string[];
+}
+export interface ParsedDiff {
+    /** File path */
+    filename: string;
+    /** File status */
+    status: 'added' | 'removed' | 'modified' | 'renamed';
+    /** Individual hunks in this file */
+    hunks: DiffHunk[];
+    /** The full patch string */
+    rawPatch: string;
+}
+/**
+ * Parse a unified diff patch into hunks.
+ */
+export declare function parsePatch(patch: string): DiffHunk[];
+/**
+ * Parse a file's patch into a structured diff object.
+ */
+export declare function parseFileDiff(filename: string, patch: string, status?: 'added' | 'removed' | 'modified' | 'renamed'): ParsedDiff;
+/**
+ * Get the line range covered by a hunk (in the new file).
+ */
+export declare function getHunkLineRange(hunk: DiffHunk): {
+    start: number;
+    end: number;
+};
+/**
+ * Get an expanded line range for context.
+ */
+export declare function getExpandedLineRange(hunk: DiffHunk, contextLines?: number): {
+    start: number;
+    end: number;
+};
+//# sourceMappingURL=parser.d.ts.map

package/dist/action/diff/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,QAAQ;IACvB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB;IAClB,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;IACrD,oCAAoC;IACpC,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AA8BD;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CA6CpD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,SAAsB,GAChE,UAAU,CAOZ;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAK/E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,YAAY,SAAK,GAChB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAMhC"}

package/dist/action/diff/parser.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parser.test.d.ts.map

package/dist/action/diff/parser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.test.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/diff/parser.test.ts"],"names":[],"mappings":""}

package/dist/action/event/context.d.ts

@@ -0,0 +1,9 @@
+import type { Octokit } from '@octokit/rest';
+import { type EventContext } from '../types/index.js';
+export declare class EventContextError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function buildEventContext(eventName: string, eventPayload: unknown, repoPath: string, octokit: Octokit): Promise<EventContext>;
+//# sourceMappingURL=context.d.ts.map

package/dist/action/event/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/event/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAEL,KAAK,YAAY,EAIlB,MAAM,mBAAmB,CAAC;AAkC3B,qBAAa,iBAAkB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAI3D;AAED,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,YAAY,CAAC,CAuDvB"}

package/dist/action/event/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context.js';
+export * from './schedule-context.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/action/event/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/event/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC"}

package/dist/action/event/schedule-context.d.ts

@@ -0,0 +1,30 @@
+import type { EventContext, FileChange } from '../types/index.js';
+export interface ScheduleContextOptions {
+    /** Glob patterns from trigger's filters.paths */
+    patterns: string[];
+    /** Glob patterns from trigger's filters.ignorePaths */
+    ignorePatterns?: string[];
+    /** Repository root path (GITHUB_WORKSPACE) */
+    repoPath: string;
+    /** Repository owner (from GITHUB_REPOSITORY) */
+    owner: string;
+    /** Repository name */
+    name: string;
+    /** Default branch name */
+    defaultBranch: string;
+    /** Current commit SHA */
+    headSha: string;
+}
+/**
+ * Build an EventContext for scheduled runs.
+ *
+ * Creates a synthetic pullRequest context from file globs using real repo info.
+ * The runner processes this normally because the files have patch data.
+ */
+export declare function buildScheduleEventContext(options: ScheduleContextOptions): Promise<EventContext>;
+/**
+ * Filter file changes to only include files matching the given patterns.
+ * Used when a schedule trigger has specific path filters.
+ */
+export declare function filterFilesByPatterns(files: FileChange[], patterns: string[], ignorePatterns?: string[]): FileChange[];
+//# sourceMappingURL=schedule-context.d.ts.map

package/dist/action/event/schedule-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-context.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/event/schedule-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIlE,MAAM,WAAW,sBAAsB;IACrC,iDAAiD;IACjD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,YAAY,CAAC,CA8CvB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EAAE,EACnB,QAAQ,EAAE,MAAM,EAAE,EAClB,cAAc,CAAC,EAAE,MAAM,EAAE,GACxB,UAAU,EAAE,CAed"}

package/dist/action/examples/examples.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=examples.integration.test.d.ts.map

package/dist/action/examples/examples.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.integration.test.d.ts","sourceRoot":"","sources":["file:///home/runner/work/warden/warden/src/examples/examples.integration.test.ts"],"names":[],"mappings":""}