@greyworld/code-check-core 1.0.0

package/dist/tools/ast-parser/markdown/types.d.ts

@@ -0,0 +1,131 @@
+import type { Node } from "commonmark";
+/**
+ * Markdown node types defined in CommonMark specification,
+ * extended with "frontmatter" for YAML front-matter blocks.
+ */
+export type MarkdownNodeType = "document" | "block_quote" | "list" | "item" | "paragraph" | "heading" | "emph" | "strong" | "link" | "image" | "code" | "code_block" | "thematic_break" | "softbreak" | "linebreak" | "html_block" | "html_inline" | "text" | "custom_block" | "custom_inline" | "frontmatter";
+/**
+ * List type for list nodes
+ */
+export type ListType = "bullet" | "ordered";
+/**
+ * Position information for a node in the source document
+ */
+export interface SourcePosition {
+    line: number;
+    column: number;
+}
+/**
+ * Source location range for a node
+ */
+export interface SourceRange {
+    start: SourcePosition;
+    end: SourcePosition;
+}
+/**
+ * Simplified markdown AST node interface
+ */
+export interface MarkdownNode {
+    /**
+     * The type of the node
+     */
+    type: MarkdownNodeType;
+    /**
+     * Text content for text, code, code_block, and html nodes
+     */
+    literal: string | null;
+    /**
+     * Destination URL for link and image nodes
+     */
+    destination: string | null;
+    /**
+     * Title for link and image nodes
+     */
+    title: string | null;
+    /**
+     * Info string for code_block nodes (e.g., language identifier)
+     */
+    info: string | null;
+    /**
+     * Heading level (1-6) for heading nodes
+     */
+    level: number | null;
+    /**
+     * List type for list nodes
+     */
+    listType: ListType | null;
+    /**
+     * Whether the list is tight (no blank lines between items)
+     */
+    listTight: boolean | null;
+    /**
+     * Starting number for ordered lists
+     */
+    listStart: number | null;
+    /**
+     * Delimiter for ordered lists ("." or ")")
+     */
+    listDelimiter: string | null;
+    /**
+     * Parsed key-value data for frontmatter nodes (YAML content)
+     */
+    data: Record<string, unknown> | null;
+    /**
+     * Source location in the original document
+     */
+    sourceRange: SourceRange | null;
+    /**
+     * Child nodes
+     */
+    children: MarkdownNode[];
+}
+/**
+ * Walker event for traversing the AST
+ */
+export interface WalkEvent {
+    /**
+     * Whether this is an entering or leaving event
+     */
+    entering: boolean;
+    /**
+     * The current node
+     */
+    node: MarkdownNode;
+}
+/**
+ * Visitor callback function type
+ */
+export type NodeVisitor = (node: MarkdownNode, entering: boolean) => void;
+/**
+ * Type-specific visitor callbacks
+ */
+export type TypedVisitors = {
+    [K in MarkdownNodeType]?: NodeVisitor;
+};
+/**
+ * Options for the markdown parser
+ */
+export interface ParserOptions {
+    /**
+     * Whether to enable smart punctuation (e.g., converting quotes)
+     */
+    smart?: boolean;
+    /**
+     * Maximum nesting level for nested content
+     */
+    maxNesting?: number;
+    /**
+     * Whether to enable YAML front-matter parsing.
+     * When enabled, the parser extracts the leading `---...---` block,
+     * parses its YAML content, and inserts a "frontmatter" node as
+     * the first child of the document node.
+     *
+     * @default true
+     */
+    enableFrontmatter?: boolean;
+}
+/**
+ * Re-export the original commonmark Node type for advanced usage
+ */
+export type { Node as CommonMarkNode };
+//# sourceMappingURL=types.d.ts.map

package/dist/tools/ast-parser/markdown/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tools/ast-parser/markdown/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GACtB,UAAU,GACV,aAAa,GACb,MAAM,GACN,MAAM,GACN,WAAW,GACX,SAAS,GACT,MAAM,GACN,QAAQ,GACR,MAAM,GACN,OAAO,GACP,MAAM,GACN,YAAY,GACZ,gBAAgB,GAChB,WAAW,GACX,WAAW,GACX,YAAY,GACZ,aAAa,GACb,MAAM,GACN,cAAc,GACd,eAAe,GACf,aAAa,CAAC;AAEpB;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,cAAc,CAAC;IACtB,GAAG,EAAE,cAAc,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB;;OAEG;IACH,IAAI,EAAE,gBAAgB,CAAC;IAEvB;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvB;;OAEG;IACH,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;OAEG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB;;OAEG;IACH,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpB;;OAEG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB;;OAEG;IACH,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB;;OAEG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAE7B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAErC;;OAEG;IACH,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhC;;OAEG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,IAAI,EAAE,YAAY,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;AAE1E;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;KACvB,CAAC,IAAI,gBAAgB,CAAC,CAAC,EAAE,WAAW;CACxC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;GAEG;AACH,YAAY,EAAE,IAAI,IAAI,cAAc,EAAE,CAAC"}

package/dist/tools/ast-parser/markdown/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/tools/ast-parser/markdown/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/tools/ast-parser/markdown/types.ts"],"names":[],"mappings":""}

package/dist/tools/env/index.d.ts

@@ -0,0 +1,2 @@
+export { loadEnvFile } from "./load-env";
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/env/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/env/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/tools/env/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnvFile = void 0;
+var load_env_1 = require("./load-env");
+Object.defineProperty(exports, "loadEnvFile", { enumerable: true, get: function () { return load_env_1.loadEnvFile; } });
+//# sourceMappingURL=index.js.map

package/dist/tools/env/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tools/env/index.ts"],"names":[],"mappings":";;;AAAA,uCAAyC;AAAhC,uGAAA,WAAW,OAAA"}

package/dist/tools/env/load-env.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Load key-value pairs from workspace `.env` into `process.env`.
+ *
+ * - Reads `<cwd>/.env`
+ * - Skips blank lines and `#` comments
+ * - Does not overwrite pre-existing environment variables
+ */
+export declare function loadEnvFile(): void;
+//# sourceMappingURL=load-env.d.ts.map

package/dist/tools/env/load-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-env.d.ts","sourceRoot":"","sources":["../../../src/tools/env/load-env.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAgB,WAAW,IAAI,IAAI,CA2BlC"}

package/dist/tools/env/load-env.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnvFile = loadEnvFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+let loaded = false;
+/**
+ * Load key-value pairs from workspace `.env` into `process.env`.
+ *
+ * - Reads `<cwd>/.env`
+ * - Skips blank lines and `#` comments
+ * - Does not overwrite pre-existing environment variables
+ */
+function loadEnvFile() {
+    if (loaded)
+        return;
+    const envPath = (0, path_1.resolve)(process.cwd(), ".env");
+    if (!(0, fs_1.existsSync)(envPath)) {
+        loaded = true;
+        return;
+    }
+    const content = (0, fs_1.readFileSync)(envPath, "utf8");
+    const lines = content.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const separatorIndex = line.indexOf("=");
+        if (separatorIndex <= 0)
+            continue;
+        const key = line.slice(0, separatorIndex).trim();
+        if (!key || process.env[key] !== undefined)
+            continue;
+        const value = line.slice(separatorIndex + 1).trim();
+        process.env[key] = value;
+    }
+    loaded = true;
+}
+//# sourceMappingURL=load-env.js.map

package/dist/tools/env/load-env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-env.js","sourceRoot":"","sources":["../../../src/tools/env/load-env.ts"],"names":[],"mappings":";;AAYA,kCA2BC;AAvCD,2BAA8C;AAC9C,+BAA+B;AAE/B,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB;;;;;;GAMG;AACH,SAAgB,WAAW;IACvB,IAAI,MAAM;QAAE,OAAO;IAEnB,MAAM,OAAO,GAAG,IAAA,cAAO,EAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC;IAC/C,IAAI,CAAC,IAAA,eAAU,EAAC,OAAO,CAAC,EAAE,CAAC;QACvB,MAAM,GAAG,IAAI,CAAC;QACd,OAAO;IACX,CAAC;IAED,MAAM,OAAO,GAAG,IAAA,iBAAY,EAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC9C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAErC,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE,CAAC;QAC1B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;YAAE,SAAS;QAE5C,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,cAAc,IAAI,CAAC;YAAE,SAAS;QAElC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,IAAI,EAAE,CAAC;QACjD,IAAI,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS;YAAE,SAAS;QAErD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACpD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC7B,CAAC;IAED,MAAM,GAAG,IAAI,CAAC;AAClB,CAAC"}

package/dist/tools/line-pattern/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Line Pattern Module
+ *
+ * Provides a composable, segment-based approach to defining
+ * and validating line-level text format patterns.
+ *
+ * @module tools/line-pattern
+ */
+export { LinePattern } from "./line-pattern";
+export type { LineMatchResult, LineMatchSuccess, LineMatchFailure, } from "./line-pattern";
+export type { Segment, SegmentMatchResult } from "./segment";
+export { matchSegment } from "./segment";
+export { literal, backticked, parenthesized, spaces, keyword, rest, optional, csvParenthesized, } from "./segments";
+export type { CsvSlot } from "./segments";
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/line-pattern/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/line-pattern/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACR,eAAe,EACf,gBAAgB,EAChB,gBAAgB,GACnB,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EACH,OAAO,EACP,UAAU,EACV,aAAa,EACb,MAAM,EACN,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,gBAAgB,GACnB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC"}

package/dist/tools/line-pattern/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Line Pattern Module
+ *
+ * Provides a composable, segment-based approach to defining
+ * and validating line-level text format patterns.
+ *
+ * @module tools/line-pattern
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csvParenthesized = exports.optional = exports.rest = exports.keyword = exports.spaces = exports.parenthesized = exports.backticked = exports.literal = exports.matchSegment = exports.LinePattern = void 0;
+var line_pattern_1 = require("./line-pattern");
+Object.defineProperty(exports, "LinePattern", { enumerable: true, get: function () { return line_pattern_1.LinePattern; } });
+var segment_1 = require("./segment");
+Object.defineProperty(exports, "matchSegment", { enumerable: true, get: function () { return segment_1.matchSegment; } });
+var segments_1 = require("./segments");
+Object.defineProperty(exports, "literal", { enumerable: true, get: function () { return segments_1.literal; } });
+Object.defineProperty(exports, "backticked", { enumerable: true, get: function () { return segments_1.backticked; } });
+Object.defineProperty(exports, "parenthesized", { enumerable: true, get: function () { return segments_1.parenthesized; } });
+Object.defineProperty(exports, "spaces", { enumerable: true, get: function () { return segments_1.spaces; } });
+Object.defineProperty(exports, "keyword", { enumerable: true, get: function () { return segments_1.keyword; } });
+Object.defineProperty(exports, "rest", { enumerable: true, get: function () { return segments_1.rest; } });
+Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return segments_1.optional; } });
+Object.defineProperty(exports, "csvParenthesized", { enumerable: true, get: function () { return segments_1.csvParenthesized; } });
+//# sourceMappingURL=index.js.map

package/dist/tools/line-pattern/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tools/line-pattern/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAEH,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AAQpB,qCAAyC;AAAhC,uGAAA,YAAY,OAAA;AAErB,uCASoB;AARhB,mGAAA,OAAO,OAAA;AACP,sGAAA,UAAU,OAAA;AACV,yGAAA,aAAa,OAAA;AACb,kGAAA,MAAM,OAAA;AACN,mGAAA,OAAO,OAAA;AACP,gGAAA,IAAI,OAAA;AACJ,oGAAA,QAAQ,OAAA;AACR,4GAAA,gBAAgB,OAAA"}

package/dist/tools/line-pattern/line-pattern.d.ts

@@ -0,0 +1,53 @@
+import type { Segment } from "./segment";
+export interface LineMatchFailure {
+    /** 0-based index of the segment that failed. */
+    segmentIndex: number;
+    /** The display string of the failed segment. */
+    expectedDisplay: string;
+    /** The remaining unmatched portion of the input. */
+    remaining: string;
+}
+export interface LineMatchSuccess {
+    /** The portion of input consumed by each segment. */
+    captures: string[];
+}
+export type LineMatchResult = {
+    ok: true;
+    value: LineMatchSuccess;
+} | {
+    ok: false;
+    error: LineMatchFailure;
+};
+/**
+ * A line-level format pattern composed of ordered segments.
+ *
+ * Instead of one monolithic regex, the pattern validates input
+ * by sequentially applying each segment's own small regex.
+ * This makes each piece independently readable, testable,
+ * and produces precise error reporting on mismatch.
+ */
+export declare class LinePattern {
+    private readonly segments;
+    constructor(segments: Segment[]);
+    /**
+     * Generate the human-readable display format by joining
+     * all segment display strings.
+     */
+    toDisplayFormat(): string;
+    /**
+     * Test whether the full line matches this pattern.
+     */
+    test(line: string): boolean;
+    /**
+     * Match the line against all segments sequentially.
+     *
+     * On success, returns the text captured by each segment.
+     * On failure, returns which segment failed and what remained.
+     */
+    match(line: string): LineMatchResult;
+    /**
+     * Produce a diagnostic message when a line fails to match.
+     */
+    describeFailure(line: string): string | null;
+}
+//# sourceMappingURL=line-pattern.d.ts.map

package/dist/tools/line-pattern/line-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-pattern.d.ts","sourceRoot":"","sources":["../../../src/tools/line-pattern/line-pattern.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,MAAM,WAAW,gBAAgB;IAC7B,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,gDAAgD;IAChD,eAAe,EAAE,MAAM,CAAC;IACxB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC7B,qDAAqD;IACrD,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,MAAM,eAAe,GACrB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,GACrC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE7C;;;;;;;GAOG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAY;gBAEzB,QAAQ,EAAE,OAAO,EAAE;IAI/B;;;OAGG;IACH,eAAe,IAAI,MAAM;IAMzB;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3B;;;;;OAKG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;IAyCpC;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;CAY/C"}

package/dist/tools/line-pattern/line-pattern.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinePattern = void 0;
+const segment_1 = require("./segment");
+/**
+ * A line-level format pattern composed of ordered segments.
+ *
+ * Instead of one monolithic regex, the pattern validates input
+ * by sequentially applying each segment's own small regex.
+ * This makes each piece independently readable, testable,
+ * and produces precise error reporting on mismatch.
+ */
+class LinePattern {
+    constructor(segments) {
+        this.segments = segments;
+    }
+    /**
+     * Generate the human-readable display format by joining
+     * all segment display strings.
+     */
+    toDisplayFormat() {
+        return this.segments
+            .map((s) => s.display)
+            .join("");
+    }
+    /**
+     * Test whether the full line matches this pattern.
+     */
+    test(line) {
+        return this.match(line).ok;
+    }
+    /**
+     * Match the line against all segments sequentially.
+     *
+     * On success, returns the text captured by each segment.
+     * On failure, returns which segment failed and what remained.
+     */
+    match(line) {
+        let remaining = line;
+        const captures = [];
+        for (let i = 0; i < this.segments.length; i++) {
+            const seg = this.segments[i];
+            const result = (0, segment_1.matchSegment)(seg, remaining);
+            if (!result.matched) {
+                if (seg.optional) {
+                    captures.push("");
+                    continue;
+                }
+                return {
+                    ok: false,
+                    error: {
+                        segmentIndex: i,
+                        expectedDisplay: seg.display,
+                        remaining,
+                    },
+                };
+            }
+            captures.push(remaining.slice(0, result.consumed));
+            remaining = remaining.slice(result.consumed);
+        }
+        if (remaining.length > 0) {
+            return {
+                ok: false,
+                error: {
+                    segmentIndex: this.segments.length,
+                    expectedDisplay: "<end of line>",
+                    remaining,
+                },
+            };
+        }
+        return { ok: true, value: { captures } };
+    }
+    /**
+     * Produce a diagnostic message when a line fails to match.
+     */
+    describeFailure(line) {
+        const result = this.match(line);
+        if (result.ok)
+            return null;
+        const { segmentIndex, expectedDisplay, remaining } = result.error;
+        const pos = line.length - remaining.length;
+        return (`Mismatch at position ${pos} (segment #${segmentIndex}): ` +
+            `expected ${expectedDisplay}, ` +
+            `got "${remaining.slice(0, 20)}${remaining.length > 20 ? "..." : ""}"`);
+    }
+}
+exports.LinePattern = LinePattern;
+//# sourceMappingURL=line-pattern.js.map

package/dist/tools/line-pattern/line-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-pattern.js","sourceRoot":"","sources":["../../../src/tools/line-pattern/line-pattern.ts"],"names":[],"mappings":";;;AACA,uCAAyC;AAoBzC;;;;;;;GAOG;AACH,MAAa,WAAW;IAGpB,YAAY,QAAmB;QAC3B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACH,eAAe;QACX,OAAO,IAAI,CAAC,QAAQ;aACf,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;aACrB,IAAI,CAAC,EAAE,CAAC,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,IAAY;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;IAC/B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAY;QACd,IAAI,SAAS,GAAG,IAAI,CAAC;QACrB,MAAM,QAAQ,GAAa,EAAE,CAAC;QAE9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5C,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC7B,MAAM,MAAM,GAAG,IAAA,sBAAY,EAAC,GAAG,EAAE,SAAS,CAAC,CAAC;YAE5C,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBAClB,IAAI,GAAG,CAAC,QAAQ,EAAE,CAAC;oBACf,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;oBAClB,SAAS;gBACb,CAAC;gBACD,OAAO;oBACH,EAAE,EAAE,KAAK;oBACT,KAAK,EAAE;wBACH,YAAY,EAAE,CAAC;wBACf,eAAe,EAAE,GAAG,CAAC,OAAO;wBAC5B,SAAS;qBACZ;iBACJ,CAAC;YACN,CAAC;YAED,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACnD,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACjD,CAAC;QAED,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,OAAO;gBACH,EAAE,EAAE,KAAK;gBACT,KAAK,EAAE;oBACH,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM;oBAClC,eAAe,EAAE,eAAe;oBAChC,SAAS;iBACZ;aACJ,CAAC;QACN,CAAC;QAED,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,IAAY;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,MAAM,CAAC,EAAE;YAAE,OAAO,IAAI,CAAC;QAE3B,MAAM,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC;QAClE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC;QAC3C,OAAO,CACH,wBAAwB,GAAG,cAAc,YAAY,KAAK;YAC1D,YAAY,eAAe,IAAI;YAC/B,QAAQ,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CACzE,CAAC;IACN,CAAC;CACJ;AAtFD,kCAsFC"}

package/dist/tools/line-pattern/segment.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Represents one atomic piece of a line format pattern.
+ *
+ * Each segment owns a small regex that matches its portion of the input
+ * and a human-readable placeholder used when generating display formats.
+ */
+export interface Segment {
+    /** Regex that matches this segment (must NOT be anchored with ^ or $). */
+    readonly regex: RegExp;
+    /** Human-readable placeholder, e.g. "`arg_name`" or "(Modifier, Type)". */
+    readonly display: string;
+    /** Whether this segment is optional. */
+    readonly optional?: boolean;
+}
+export interface SegmentMatchResult {
+    matched: boolean;
+    consumed: number;
+}
+/**
+ * Try to match a segment at the beginning of `input`.
+ * Returns how many characters were consumed, or -1 on failure.
+ */
+export declare function matchSegment(segment: Segment, input: string): SegmentMatchResult;
+//# sourceMappingURL=segment.d.ts.map

package/dist/tools/line-pattern/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/tools/line-pattern/segment.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACpB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,wCAAwC;IACxC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CACxB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,GACd,kBAAkB,CAMpB"}

package/dist/tools/line-pattern/segment.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchSegment = matchSegment;
+/**
+ * Try to match a segment at the beginning of `input`.
+ * Returns how many characters were consumed, or -1 on failure.
+ */
+function matchSegment(segment, input) {
+    const m = segment.regex.exec(input);
+    if (!m || m.index !== 0) {
+        return { matched: false, consumed: 0 };
+    }
+    return { matched: true, consumed: m[0].length };
+}
+//# sourceMappingURL=segment.js.map

package/dist/tools/line-pattern/segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.js","sourceRoot":"","sources":["../../../src/tools/line-pattern/segment.ts"],"names":[],"mappings":";;AA0BA,oCASC;AAbD;;;GAGG;AACH,SAAgB,YAAY,CACxB,OAAgB,EAChB,KAAa;IAEb,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;IAC3C,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;AACpD,CAAC"}

package/dist/tools/line-pattern/segments.d.ts

@@ -0,0 +1,43 @@
+import type { Segment } from "./segment";
+/**
+ * Factory functions for common segment types.
+ *
+ * Each factory returns a Segment with a focused regex and
+ * a descriptive display string.
+ */
+/** Matches an exact literal string (whitespace-flexible). */
+export declare function literal(text: string): Segment;
+/** Matches `name` — a back-ticked identifier. */
+export declare function backticked(placeholder: string): Segment;
+/** Matches (content) — parenthesized group. */
+export declare function parenthesized(placeholder: string): Segment;
+/** Matches whitespace characters. Optionally specify an exact count. */
+export declare function spaces(count?: number): Segment;
+/** Matches a fixed keyword. */
+export declare function keyword(word: string): Segment;
+/** Matches the rest of the line (at least one character). */
+export declare function rest(placeholder: string): Segment;
+/** Matches an optional segment — skipped without error if absent. */
+export declare function optional(segment: Segment): Segment;
+/** One slot in a CSV-parenthesized group. */
+export interface CsvSlot {
+    /** Display name for this slot. */
+    name: string;
+    /** Allowed values (matched literally, case-sensitive). */
+    values: string[];
+    /**
+     * If true, zero or more items from this value set may trail
+     * the required slots. Must be the last slot.
+     */
+    zeroOrMore?: boolean;
+}
+/**
+ * Matches a parenthesized, comma-separated group where each positional
+ * slot validates against a fixed set of allowed values.
+ *
+ * Required slots appear in order, separated by `, `.
+ * A trailing `zeroOrMore` slot allows 0+ extra comma-separated items
+ * drawn from its value set.
+ */
+export declare function csvParenthesized(slots: CsvSlot[]): Segment;
+//# sourceMappingURL=segments.d.ts.map

package/dist/tools/line-pattern/segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segments.d.ts","sourceRoot":"","sources":["../../../src/tools/line-pattern/segments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;;GAKG;AAEH,6DAA6D;AAC7D,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM7C;AAED,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAKvD;AAED,+CAA+C;AAC/C,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAK1D;AAED,wEAAwE;AACxE,wBAAgB,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAK9C;AAED,+BAA+B;AAC/B,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM7C;AAED,6DAA6D;AAC7D,wBAAgB,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAKjD;AAED,qEAAqE;AACrE,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAElD;AAED,6CAA6C;AAC7C,MAAM,WAAW,OAAO;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAuB1D"}

package/dist/tools/line-pattern/segments.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.literal = literal;
+exports.backticked = backticked;
+exports.parenthesized = parenthesized;
+exports.spaces = spaces;
+exports.keyword = keyword;
+exports.rest = rest;
+exports.optional = optional;
+exports.csvParenthesized = csvParenthesized;
+/**
+ * Factory functions for common segment types.
+ *
+ * Each factory returns a Segment with a focused regex and
+ * a descriptive display string.
+ */
+/** Matches an exact literal string (whitespace-flexible). */
+function literal(text) {
+    const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return {
+        regex: new RegExp(escaped),
+        display: text,
+    };
+}
+/** Matches `name` — a back-ticked identifier. */
+function backticked(placeholder) {
+    return {
+        regex: /`[^`]+`/,
+        display: `\`${placeholder}\``,
+    };
+}
+/** Matches (content) — parenthesized group. */
+function parenthesized(placeholder) {
+    return {
+        regex: /\([^)]+\)/,
+        display: `(${placeholder})`,
+    };
+}
+/** Matches whitespace characters. Optionally specify an exact count. */
+function spaces(count) {
+    return {
+        regex: count !== undefined ? new RegExp(`\\s{${count}}`) : /\s+/,
+        display: " ",
+    };
+}
+/** Matches a fixed keyword. */
+function keyword(word) {
+    const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return {
+        regex: new RegExp(escaped),
+        display: word,
+    };
+}
+/** Matches the rest of the line (at least one character). */
+function rest(placeholder) {
+    return {
+        regex: /.+/,
+        display: placeholder,
+    };
+}
+/** Matches an optional segment — skipped without error if absent. */
+function optional(segment) {
+    return { ...segment, optional: true };
+}
+/**
+ * Matches a parenthesized, comma-separated group where each positional
+ * slot validates against a fixed set of allowed values.
+ *
+ * Required slots appear in order, separated by `, `.
+ * A trailing `zeroOrMore` slot allows 0+ extra comma-separated items
+ * drawn from its value set.
+ */
+function csvParenthesized(slots) {
+    const required = slots.filter((s) => !s.zeroOrMore);
+    const trailing = slots.find((s) => s.zeroOrMore);
+    const parts = required.map((s) => `(?:${s.values.join("|")})`);
+    let inner = parts.join(",\\s+");
+    if (trailing) {
+        inner += `(?:,\\s+(?:${trailing.values.join("|")}))*`;
+    }
+    const displayParts = required.map((s) => s.name);
+    let display = displayParts.join(", ");
+    if (trailing) {
+        display += `[, ${trailing.name}...]`;
+    }
+    return {
+        regex: new RegExp(`\\(${inner}\\)`),
+        display: `(${display})`,
+    };
+}
+//# sourceMappingURL=segments.js.map

package/dist/tools/line-pattern/segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segments.js","sourceRoot":"","sources":["../../../src/tools/line-pattern/segments.ts"],"names":[],"mappings":"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"}

package/dist/tools/llm/description-intent/format-spec.d.ts

@@ -0,0 +1,3 @@
+import type { DescriptionFormatSpec, DescriptionIntent } from "./types";
+export declare function getFormatSpec(intent: DescriptionIntent): DescriptionFormatSpec | undefined;
+//# sourceMappingURL=format-spec.d.ts.map

package/dist/tools/llm/description-intent/format-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-spec.d.ts","sourceRoot":"","sources":["../../../../src/tools/llm/description-intent/format-spec.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACR,qBAAqB,EACrB,iBAAiB,EACpB,MAAM,SAAS,CAAC;AAyKjB,wBAAgB,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,qBAAqB,GAAG,SAAS,CAE1F"}