@greyworld/code-check-core 1.0.0

package/dist/tools/llm/model.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModel = createModel;
+const openai_1 = require("@langchain/openai");
+const env_1 = require("../env");
+(0, env_1.loadEnvFile)();
+function createModel(modelName = process.env.QWEN_MODEL || "qwen-plus", temperature = 0.7, streaming = false, baseURL = process.env.DASHSCOPE_BASE_URL || "", apiKey = process.env.DASHSCOPE_API_KEY || "") {
+    return new openai_1.ChatOpenAI({
+        modelName,
+        temperature,
+        streaming,
+        configuration: {
+            baseURL,
+            apiKey,
+        },
+    });
+}
+//# sourceMappingURL=model.js.map

package/dist/tools/llm/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/tools/llm/model.ts"],"names":[],"mappings":";;AAKA,kCAgBC;AArBD,8CAA+C;AAC/C,gCAAqC;AAErC,IAAA,iBAAW,GAAE,CAAC;AAEd,SAAgB,WAAW,CACvB,YAAoB,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,WAAW,EACzD,cAAsB,GAAG,EACzB,YAAqB,KAAK,EAC1B,UAAkB,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,EAAE,EACtD,SAAiB,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,EAAE;IAEpD,OAAO,IAAI,mBAAU,CAAC;QAClB,SAAS;QACT,WAAW;QACX,SAAS;QACT,aAAa,EAAE;YACX,OAAO;YACP,MAAM;SACT;KACJ,CAAC,CAAC;AACP,CAAC"}

package/dist/tools/llm/structured-caller.d.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+/**
+ * Options for creating a StructuredCaller.
+ */
+export interface StructuredCallerOptions {
+    /** Maximum retry attempts on parse / validation failure (default: 2). */
+    maxRetries?: number;
+}
+export interface StructuredCallSuccess<T> {
+    ok: true;
+    data: T;
+    /** Number of retries consumed (0 = first attempt succeeded). */
+    retries: number;
+}
+export interface StructuredCallFailure {
+    ok: false;
+    error: string;
+    retries: number;
+    /** Raw model output from the last attempt, useful for debugging. */
+    lastRaw?: string;
+}
+export type StructuredCallResult<T> = StructuredCallSuccess<T> | StructuredCallFailure;
+/**
+ * Stateless tool that calls an LLM and validates the response against a
+ * Zod schema.
+ *
+ * Workflow:
+ *  1. Append JSON format instructions (derived from the Zod schema) to
+ *     the system prompt.
+ *  2. Invoke the model.
+ *  3. Extract JSON from the raw response (handles code fences, leading
+ *     text, etc.).
+ *  4. Validate the JSON with Zod.
+ *  5. On failure, feed the error back to the model and retry up to
+ *     `maxRetries` times.
+ *
+ * Temperature is intentionally NOT managed here — configure it when
+ * creating the model (recommend 0–0.2 for structured output).
+ *
+ * @example
+ * ```typescript
+ * import { StructuredCaller } from "@code-check/core";
+ * import { z } from "zod";
+ *
+ * const caller = new StructuredCaller(model);
+ * const result = await caller.call(
+ *     z.object({
+ *         pass: z.boolean().describe("Whether the check passed"),
+ *         reason: z.string().describe("Short explanation"),
+ *     }),
+ *     "You are a document reviewer.",
+ *     "Check whether the title matches: ...",
+ * );
+ *
+ * if (result.ok) {
+ *     console.log(result.data.pass, result.data.reason);
+ * }
+ * ```
+ */
+export declare class StructuredCaller {
+    private readonly model;
+    private readonly maxRetries;
+    constructor(model: BaseChatModel, options?: StructuredCallerOptions);
+    /**
+     * Call the model and return a schema-validated result.
+     *
+     * @param schema      Zod schema defining the expected output shape.
+     * @param systemPrompt  System-level instruction (what the model should do).
+     * @param userPrompt    User-level input (the data to process).
+     */
+    call<S extends z.ZodType>(schema: S, systemPrompt: string, userPrompt: string): Promise<StructuredCallResult<z.infer<S>>>;
+}
+/**
+ * Extract a JSON value from a string that may contain surrounding text
+ * or markdown code fences.
+ *
+ * Tries three strategies in order:
+ *  1. Direct `JSON.parse` on the trimmed text.
+ *  2. Extract content from the first ``` code fence.
+ *  3. Locate the outermost `{ … }` bracket pair.
+ *
+ * Returns `null` when no valid JSON can be extracted.
+ */
+export declare function extractJson(text: string): unknown;
+//# sourceMappingURL=structured-caller.d.ts.map

package/dist/tools/llm/structured-caller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-caller.d.ts","sourceRoot":"","sources":["../../../src/tools/llm/structured-caller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAQjF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACpC,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,CAAC,CAAC;IACR,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IAClC,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAC5B,qBAAqB,CAAC,CAAC,CAAC,GACxB,qBAAqB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,uBAA4B;IAKvE;;;;;;OAMG;IACU,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EACjC,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACnB,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;CAsE/C;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CA0BjD"}

package/dist/tools/llm/structured-caller.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructuredCaller = void 0;
+exports.extractJson = extractJson;
+const zod_1 = require("zod");
+const messages_1 = require("@langchain/core/messages");
+/**
+ * Stateless tool that calls an LLM and validates the response against a
+ * Zod schema.
+ *
+ * Workflow:
+ *  1. Append JSON format instructions (derived from the Zod schema) to
+ *     the system prompt.
+ *  2. Invoke the model.
+ *  3. Extract JSON from the raw response (handles code fences, leading
+ *     text, etc.).
+ *  4. Validate the JSON with Zod.
+ *  5. On failure, feed the error back to the model and retry up to
+ *     `maxRetries` times.
+ *
+ * Temperature is intentionally NOT managed here — configure it when
+ * creating the model (recommend 0–0.2 for structured output).
+ *
+ * @example
+ * ```typescript
+ * import { StructuredCaller } from "@code-check/core";
+ * import { z } from "zod";
+ *
+ * const caller = new StructuredCaller(model);
+ * const result = await caller.call(
+ *     z.object({
+ *         pass: z.boolean().describe("Whether the check passed"),
+ *         reason: z.string().describe("Short explanation"),
+ *     }),
+ *     "You are a document reviewer.",
+ *     "Check whether the title matches: ...",
+ * );
+ *
+ * if (result.ok) {
+ *     console.log(result.data.pass, result.data.reason);
+ * }
+ * ```
+ */
+class StructuredCaller {
+    constructor(model, options = {}) {
+        this.model = model;
+        this.maxRetries = options.maxRetries ?? 2;
+    }
+    /**
+     * Call the model and return a schema-validated result.
+     *
+     * @param schema      Zod schema defining the expected output shape.
+     * @param systemPrompt  System-level instruction (what the model should do).
+     * @param userPrompt    User-level input (the data to process).
+     */
+    async call(schema, systemPrompt, userPrompt) {
+        const formatBlock = buildFormatInstruction(schema);
+        const messages = [
+            new messages_1.SystemMessage(systemPrompt + "\n\n" + formatBlock),
+            new messages_1.HumanMessage(userPrompt),
+        ];
+        let lastRaw;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            let raw;
+            try {
+                const response = await this.model.invoke(messages);
+                raw = typeof response.content === "string"
+                    ? response.content
+                    : JSON.stringify(response.content);
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: `Model invocation failed: ${err instanceof Error ? err.message : String(err)}`,
+                    retries: attempt,
+                    lastRaw,
+                };
+            }
+            lastRaw = raw;
+            // ── Step 1: extract JSON ──
+            const json = extractJson(raw);
+            if (json === null) {
+                if (attempt < this.maxRetries) {
+                    messages.push(new messages_1.AIMessage(raw), new messages_1.HumanMessage("Your response could not be parsed as JSON. " +
+                        "Please respond with ONLY a valid JSON object, " +
+                        "no extra text or markdown fences."));
+                }
+                continue;
+            }
+            // ── Step 2: validate against schema ──
+            const parsed = schema.safeParse(json);
+            if (parsed.success) {
+                return { ok: true, data: parsed.data, retries: attempt };
+            }
+            if (attempt < this.maxRetries) {
+                messages.push(new messages_1.AIMessage(raw), new messages_1.HumanMessage("Your JSON was valid but did not match the required schema.\n" +
+                    `Validation errors:\n${formatZodError(parsed.error)}\n` +
+                    "Please fix and respond with ONLY the corrected JSON."));
+            }
+        }
+        return {
+            ok: false,
+            error: `Failed to get valid structured output after ${this.maxRetries + 1} attempts`,
+            retries: this.maxRetries,
+            lastRaw,
+        };
+    }
+}
+exports.StructuredCaller = StructuredCaller;
+// ── Utilities ──────────────────────────────────────────────────────────
+/**
+ * Extract a JSON value from a string that may contain surrounding text
+ * or markdown code fences.
+ *
+ * Tries three strategies in order:
+ *  1. Direct `JSON.parse` on the trimmed text.
+ *  2. Extract content from the first ``` code fence.
+ *  3. Locate the outermost `{ … }` bracket pair.
+ *
+ * Returns `null` when no valid JSON can be extracted.
+ */
+function extractJson(text) {
+    const trimmed = text.trim();
+    // 1. Direct parse
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch { /* continue */ }
+    // 2. Markdown code fence
+    const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (fenceMatch) {
+        try {
+            return JSON.parse(fenceMatch[1].trim());
+        }
+        catch { /* continue */ }
+    }
+    // 3. Outermost braces
+    const open = trimmed.indexOf("{");
+    const close = trimmed.lastIndexOf("}");
+    if (open !== -1 && close > open) {
+        try {
+            return JSON.parse(trimmed.slice(open, close + 1));
+        }
+        catch { /* continue */ }
+    }
+    return null;
+}
+// ── Internal helpers ──────────────────────────────────────────────────
+function buildFormatInstruction(schema) {
+    let schemaStr;
+    try {
+        const jsonSchema = zod_1.z.toJSONSchema(schema);
+        const { $schema: _dropped, ...rest } = jsonSchema;
+        schemaStr = JSON.stringify(rest, null, 2);
+    }
+    catch {
+        schemaStr = "(schema unavailable — follow the instructions above)";
+    }
+    return [
+        "## Response Format",
+        "",
+        "You MUST respond with ONLY a valid JSON object.",
+        "Do NOT wrap it in markdown code fences or add any explanatory text.",
+        "The JSON must conform to this schema:",
+        "",
+        schemaStr,
+    ].join("\n");
+}
+function formatZodError(error) {
+    if (error &&
+        typeof error === "object" &&
+        "issues" in error &&
+        Array.isArray(error.issues)) {
+        const issues = error.issues;
+        return issues
+            .map((i) => `  - ${i.path.join(".")}: ${i.message}`)
+            .join("\n");
+    }
+    return String(error);
+}
+//# sourceMappingURL=structured-caller.js.map

package/dist/tools/llm/structured-caller.js.map

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

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

@@ -0,0 +1,17 @@
+/**
+ * Node Pattern Module
+ *
+ * Provides a composable, matcher-based approach to defining
+ * and validating AST node sequence patterns.
+ *
+ * Analogous to LinePattern for text lines — NodePattern works
+ * on flat arrays of MarkdownNode siblings.
+ *
+ * @module tools/node-pattern
+ */
+export { NodePattern } from "./node-pattern";
+export type { NodeMatchResult, NodePatternMatch, NodeMatchFailure, } from "./node-pattern";
+export type { NodeMatcher, GroupMatcher, NodeMatchElement, Quantifier, NodeMatchSegmentResult, GroupMatchSegmentResult, } from "./node-matcher";
+export { matchNodes, matchGroup, isGroupMatcher } from "./node-matcher";
+export { nodeType, heading, codeBlock, list, nodeWhere, anyNode, optionalNode, zeroOrMore, oneOrMore, tagged, group, optionalGroup, zeroOrMoreGroup, oneOrMoreGroup, } from "./matchers";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/node-pattern/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACR,eAAe,EACf,gBAAgB,EAChB,gBAAgB,GACnB,MAAM,gBAAgB,CAAC;AAExB,YAAY,EACR,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,sBAAsB,EACtB,uBAAuB,GAC1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAExE,OAAO,EACH,QAAQ,EACR,OAAO,EACP,SAAS,EACT,IAAI,EACJ,SAAS,EACT,OAAO,EACP,YAAY,EACZ,UAAU,EACV,SAAS,EACT,MAAM,EACN,KAAK,EACL,aAAa,EACb,eAAe,EACf,cAAc,GACjB,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Node Pattern Module
+ *
+ * Provides a composable, matcher-based approach to defining
+ * and validating AST node sequence patterns.
+ *
+ * Analogous to LinePattern for text lines — NodePattern works
+ * on flat arrays of MarkdownNode siblings.
+ *
+ * @module tools/node-pattern
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneOrMoreGroup = exports.zeroOrMoreGroup = exports.optionalGroup = exports.group = exports.tagged = exports.oneOrMore = exports.zeroOrMore = exports.optionalNode = exports.anyNode = exports.nodeWhere = exports.list = exports.codeBlock = exports.heading = exports.nodeType = exports.isGroupMatcher = exports.matchGroup = exports.matchNodes = exports.NodePattern = void 0;
+var node_pattern_1 = require("./node-pattern");
+Object.defineProperty(exports, "NodePattern", { enumerable: true, get: function () { return node_pattern_1.NodePattern; } });
+var node_matcher_1 = require("./node-matcher");
+Object.defineProperty(exports, "matchNodes", { enumerable: true, get: function () { return node_matcher_1.matchNodes; } });
+Object.defineProperty(exports, "matchGroup", { enumerable: true, get: function () { return node_matcher_1.matchGroup; } });
+Object.defineProperty(exports, "isGroupMatcher", { enumerable: true, get: function () { return node_matcher_1.isGroupMatcher; } });
+var matchers_1 = require("./matchers");
+Object.defineProperty(exports, "nodeType", { enumerable: true, get: function () { return matchers_1.nodeType; } });
+Object.defineProperty(exports, "heading", { enumerable: true, get: function () { return matchers_1.heading; } });
+Object.defineProperty(exports, "codeBlock", { enumerable: true, get: function () { return matchers_1.codeBlock; } });
+Object.defineProperty(exports, "list", { enumerable: true, get: function () { return matchers_1.list; } });
+Object.defineProperty(exports, "nodeWhere", { enumerable: true, get: function () { return matchers_1.nodeWhere; } });
+Object.defineProperty(exports, "anyNode", { enumerable: true, get: function () { return matchers_1.anyNode; } });
+Object.defineProperty(exports, "optionalNode", { enumerable: true, get: function () { return matchers_1.optionalNode; } });
+Object.defineProperty(exports, "zeroOrMore", { enumerable: true, get: function () { return matchers_1.zeroOrMore; } });
+Object.defineProperty(exports, "oneOrMore", { enumerable: true, get: function () { return matchers_1.oneOrMore; } });
+Object.defineProperty(exports, "tagged", { enumerable: true, get: function () { return matchers_1.tagged; } });
+Object.defineProperty(exports, "group", { enumerable: true, get: function () { return matchers_1.group; } });
+Object.defineProperty(exports, "optionalGroup", { enumerable: true, get: function () { return matchers_1.optionalGroup; } });
+Object.defineProperty(exports, "zeroOrMoreGroup", { enumerable: true, get: function () { return matchers_1.zeroOrMoreGroup; } });
+Object.defineProperty(exports, "oneOrMoreGroup", { enumerable: true, get: function () { return matchers_1.oneOrMoreGroup; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tools/node-pattern/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAEH,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AAepB,+CAAwE;AAA/D,0GAAA,UAAU,OAAA;AAAE,0GAAA,UAAU,OAAA;AAAE,8GAAA,cAAc,OAAA;AAE/C,uCAeoB;AAdhB,oGAAA,QAAQ,OAAA;AACR,mGAAA,OAAO,OAAA;AACP,qGAAA,SAAS,OAAA;AACT,gGAAA,IAAI,OAAA;AACJ,qGAAA,SAAS,OAAA;AACT,mGAAA,OAAO,OAAA;AACP,wGAAA,YAAY,OAAA;AACZ,sGAAA,UAAU,OAAA;AACV,qGAAA,SAAS,OAAA;AACT,kGAAA,MAAM,OAAA;AACN,iGAAA,KAAK,OAAA;AACL,yGAAA,aAAa,OAAA;AACb,2GAAA,eAAe,OAAA;AACf,0GAAA,cAAc,OAAA"}

package/dist/tools/node-pattern/matchers.d.ts

@@ -0,0 +1,61 @@
+import type { MarkdownNode, MarkdownNodeType, ListType } from "../ast-parser/markdown";
+import type { NodeMatcher, GroupMatcher } from "./node-matcher";
+/**
+ * Match a node by its type.
+ */
+export declare function nodeType(type: MarkdownNodeType, display?: string): NodeMatcher;
+/**
+ * Match a heading node with a specific level.
+ */
+export declare function heading(level: number): NodeMatcher;
+/**
+ * Match a code_block node, optionally restricted by info string.
+ */
+export declare function codeBlock(info?: string): NodeMatcher;
+/**
+ * Match a list node, optionally restricted by list type.
+ */
+export declare function list(listType?: ListType): NodeMatcher;
+/**
+ * Match a node using a custom predicate.
+ */
+export declare function nodeWhere(predicate: (n: MarkdownNode) => boolean, display: string): NodeMatcher;
+/**
+ * Match any single node.
+ */
+export declare function anyNode(): NodeMatcher;
+/**
+ * Make a matcher optional (0 or 1).
+ */
+export declare function optionalNode(matcher: NodeMatcher): NodeMatcher;
+/**
+ * Allow a matcher to consume zero or more consecutive nodes.
+ */
+export declare function zeroOrMore(matcher: NodeMatcher): NodeMatcher;
+/**
+ * Require a matcher to consume one or more consecutive nodes.
+ */
+export declare function oneOrMore(matcher: NodeMatcher): NodeMatcher;
+/**
+ * Attach a named tag so captured nodes are accessible by name.
+ * Works on both single matchers and group matchers.
+ */
+export declare function tagged(tag: string, element: NodeMatcher): NodeMatcher;
+export declare function tagged(tag: string, element: GroupMatcher): GroupMatcher;
+/**
+ * Match a sequence of matchers exactly once as a group.
+ */
+export declare function group(matchers: NodeMatcher[]): GroupMatcher;
+/**
+ * Match a sequence of matchers zero or one time.
+ */
+export declare function optionalGroup(matchers: NodeMatcher[]): GroupMatcher;
+/**
+ * Match a sequence of matchers zero or more times (greedy).
+ */
+export declare function zeroOrMoreGroup(matchers: NodeMatcher[]): GroupMatcher;
+/**
+ * Match a sequence of matchers one or more times (greedy).
+ */
+export declare function oneOrMoreGroup(matchers: NodeMatcher[]): GroupMatcher;
+//# sourceMappingURL=matchers.d.ts.map

package/dist/tools/node-pattern/matchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../../../src/tools/node-pattern/matchers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAoB,YAAY,EAAc,MAAM,gBAAgB,CAAC;AAM9F;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,CAM9E;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAMlD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,WAAW,CAQpD;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,CAQrD;AAED;;GAEG;AACH,wBAAgB,SAAS,CACrB,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,EACvC,OAAO,EAAE,MAAM,GAChB,WAAW,CAEb;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,WAAW,CAMrC;AAID;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,CAE9D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,CAM5D;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,CAM3D;AAID;;;GAGG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,WAAW,CAAC;AACvE,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY,CAAC;AAWzE;;GAEG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,YAAY,CAO3D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,YAAY,CAOnE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,YAAY,CAOrE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,YAAY,CAOpE"}

package/dist/tools/node-pattern/matchers.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeType = nodeType;
+exports.heading = heading;
+exports.codeBlock = codeBlock;
+exports.list = list;
+exports.nodeWhere = nodeWhere;
+exports.anyNode = anyNode;
+exports.optionalNode = optionalNode;
+exports.zeroOrMore = zeroOrMore;
+exports.oneOrMore = oneOrMore;
+exports.tagged = tagged;
+exports.group = group;
+exports.optionalGroup = optionalGroup;
+exports.zeroOrMoreGroup = zeroOrMoreGroup;
+exports.oneOrMoreGroup = oneOrMoreGroup;
+function one() {
+    return { type: "one" };
+}
+/**
+ * Match a node by its type.
+ */
+function nodeType(type, display) {
+    return {
+        predicate: (n) => n.type === type,
+        display: display ?? type,
+        quantifier: one(),
+    };
+}
+/**
+ * Match a heading node with a specific level.
+ */
+function heading(level) {
+    return {
+        predicate: (n) => n.type === "heading" && n.level === level,
+        display: `heading(${level})`,
+        quantifier: one(),
+    };
+}
+/**
+ * Match a code_block node, optionally restricted by info string.
+ */
+function codeBlock(info) {
+    const predicate = info != null
+        ? (n) => n.type === "code_block" && n.info === info
+        : (n) => n.type === "code_block";
+    const display = info != null ? `code_block(${info})` : "code_block";
+    return { predicate, display, quantifier: one() };
+}
+/**
+ * Match a list node, optionally restricted by list type.
+ */
+function list(listType) {
+    const predicate = listType != null
+        ? (n) => n.type === "list" && n.listType === listType
+        : (n) => n.type === "list";
+    const display = listType != null ? `list(${listType})` : "list";
+    return { predicate, display, quantifier: one() };
+}
+/**
+ * Match a node using a custom predicate.
+ */
+function nodeWhere(predicate, display) {
+    return { predicate, display, quantifier: one() };
+}
+/**
+ * Match any single node.
+ */
+function anyNode() {
+    return {
+        predicate: () => true,
+        display: "*",
+        quantifier: one(),
+    };
+}
+// ── Quantifier modifiers (single node) ──
+/**
+ * Make a matcher optional (0 or 1).
+ */
+function optionalNode(matcher) {
+    return { ...matcher, quantifier: { type: "optional" } };
+}
+/**
+ * Allow a matcher to consume zero or more consecutive nodes.
+ */
+function zeroOrMore(matcher) {
+    return {
+        ...matcher,
+        display: `[${matcher.display}]*`,
+        quantifier: { type: "zeroOrMore" },
+    };
+}
+/**
+ * Require a matcher to consume one or more consecutive nodes.
+ */
+function oneOrMore(matcher) {
+    return {
+        ...matcher,
+        display: `[${matcher.display}]+`,
+        quantifier: { type: "oneOrMore" },
+    };
+}
+function tagged(tag, element) {
+    return { ...element, tag };
+}
+// ── Group combinators ──
+function groupDisplay(matchers, suffix) {
+    return `(${matchers.map((m) => m.display).join(" ")})${suffix}`;
+}
+/**
+ * Match a sequence of matchers exactly once as a group.
+ */
+function group(matchers) {
+    return {
+        kind: "group",
+        matchers,
+        display: groupDisplay(matchers, ""),
+        quantifier: one(),
+    };
+}
+/**
+ * Match a sequence of matchers zero or one time.
+ */
+function optionalGroup(matchers) {
+    return {
+        kind: "group",
+        matchers,
+        display: groupDisplay(matchers, "?"),
+        quantifier: { type: "optional" },
+    };
+}
+/**
+ * Match a sequence of matchers zero or more times (greedy).
+ */
+function zeroOrMoreGroup(matchers) {
+    return {
+        kind: "group",
+        matchers,
+        display: groupDisplay(matchers, "*"),
+        quantifier: { type: "zeroOrMore" },
+    };
+}
+/**
+ * Match a sequence of matchers one or more times (greedy).
+ */
+function oneOrMoreGroup(matchers) {
+    return {
+        kind: "group",
+        matchers,
+        display: groupDisplay(matchers, "+"),
+        quantifier: { type: "oneOrMore" },
+    };
+}
+//# sourceMappingURL=matchers.js.map

package/dist/tools/node-pattern/matchers.js.map

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

package/dist/tools/node-pattern/node-matcher.d.ts

@@ -0,0 +1,69 @@
+import type { MarkdownNode } from "../ast-parser/markdown";
+/**
+ * Controls how many consecutive nodes a single matcher consumes.
+ */
+export type Quantifier = {
+    type: "one";
+} | {
+    type: "optional";
+} | {
+    type: "zeroOrMore";
+} | {
+    type: "oneOrMore";
+};
+/**
+ * Atomic unit for matching a single AST node.
+ *
+ * Analogous to `Segment` in LinePattern — each matcher owns
+ * a predicate instead of a regex, plus a human-readable display
+ * string used in diagnostics and `toDisplayFormat()`.
+ */
+export interface NodeMatcher {
+    readonly predicate: (node: MarkdownNode) => boolean;
+    readonly display: string;
+    readonly quantifier: Quantifier;
+    readonly tag?: string;
+}
+/**
+ * A group of matchers treated as a single repeatable unit.
+ *
+ * The inner matcher sequence is matched as a whole, and the
+ * quantifier controls how many times the sequence repeats.
+ * Similar to `(A B C)+` in regex.
+ */
+export interface GroupMatcher {
+    readonly kind: "group";
+    readonly matchers: NodeMatcher[];
+    readonly display: string;
+    readonly quantifier: Quantifier;
+    readonly tag?: string;
+}
+/**
+ * Either a single-node matcher or a group of matchers.
+ */
+export type NodeMatchElement = NodeMatcher | GroupMatcher;
+export declare function isGroupMatcher(el: NodeMatchElement): el is GroupMatcher;
+export interface NodeMatchSegmentResult {
+    matched: boolean;
+    consumed: number;
+}
+export interface GroupMatchSegmentResult {
+    matched: boolean;
+    consumed: number;
+    innerTags: Record<string, MarkdownNode[]>;
+}
+/**
+ * Try to consume nodes from `nodes[offset..]` according to
+ * the matcher's quantifier.
+ *
+ * Returns how many nodes were consumed (greedy for multi-quantifiers).
+ */
+export declare function matchNodes(matcher: NodeMatcher, nodes: MarkdownNode[], offset: number): NodeMatchSegmentResult;
+/**
+ * Try to match a group (a sequence of matchers repeated per quantifier).
+ *
+ * Inner matcher tags are accumulated across all iterations
+ * into `innerTags`.
+ */
+export declare function matchGroup(group: GroupMatcher, nodes: MarkdownNode[], offset: number): GroupMatchSegmentResult;
+//# sourceMappingURL=node-matcher.d.ts.map