reasonix 0.50.1 → 0.51.0

package/dist/cli/{chunk-IBRTU5WO.js → chunk-FP7IOWBQ.js}

@@ -1,64 +1,5 @@
 #!/usr/bin/env node
 import { createRequire as __cr } from 'node:module'; if (typeof globalThis.require === 'undefined') { globalThis.require = __cr(import.meta.url); }
-import {
-  bootstrapSemanticSearchInCodeMode
-} from "./chunk-WSBFVOCO.js";
-import {
-  registerSkillTools
-} from "./chunk-XWPZHWC2.js";
-import {
-  preflightStdioSpec
-} from "./chunk-SVD4UPRQ.js";
-import {
-  SHARED_SUBAGENT_SINK,
-  ToolRegistry,
-  formatSubagentResult,
-  registerChoiceTool,
-  registerFilesystemTools,
-  registerMemoryTools,
-  registerPlanTool,
-  registerTodoTool,
-  registerWebTools,
-  spawnSubagent
-} from "./chunk-GPUH2BNM.js";
-import {
-  JobRegistry,
-  registerShellTools
-} from "./chunk-6IUMTRFP.js";
-import {
-  SkillStore
-} from "./chunk-ENFBF6HI.js";
-import {
-  MCP_CATALOG
-} from "./chunk-PLHAZOLZ.js";
-import {
-  DeepSeekClient
-} from "./chunk-EZ57UEZQ.js";
-import {
-  defaultConfigPath,
-  loadEditMode,
-  loadEndpoint,
-  loadFilesystemOutlineThresholdBytes,
-  loadJavaSourceEnabled,
-  loadProjectShellAllowed,
-  loadResolvedSkillPaths,
-  loadSubagentModels,
-  loadToolRateLimit,
-  parseMcpSpec,
-  readConfig,
-  searchEnabled,
-  writeConfig
-} from "./chunk-MXWPAPZW.js";
-
-// src/tools/code-query.ts
-import { readFile } from "fs/promises";
-import { resolve as pathResolve } from "path";
-
-// src/code-query/parser.ts
-import { existsSync, readFileSync } from "fs";
-import { createRequire } from "module";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
 
 // node_modules/web-tree-sitter/web-tree-sitter.js
 var __defProp = Object.defineProperty;
@@ -1531,8 +1472,8 @@ var Language = class _Language {
     if (input instanceof Uint8Array) {
       binary2 = input;
     } else if (globalThis.process?.versions.node) {
-      const fs22 = await import("fs/promises");
-      binary2 = await fs22.readFile(input);
+      const fs2 = await import("fs/promises");
+      binary2 = await fs2.readFile(input);
     } else {
       const response = await fetch(input);
       if (!response.ok) {
@@ -1583,11 +1524,11 @@ async function Module2(moduleArg = {}) {
   }, "quit_");
   var _scriptName = import.meta.url;
   var scriptDirectory = "";
-  function locateFile(path2) {
+  function locateFile(path) {
     if (Module["locateFile"]) {
-      return Module["locateFile"](path2, scriptDirectory);
+      return Module["locateFile"](path, scriptDirectory);
     }
-    return scriptDirectory + path2;
+    return scriptDirectory + path;
   }
   __name(locateFile, "locateFile");
   var readAsync, readBinary;
@@ -1634,13 +1575,13 @@ async function Module2(moduleArg = {}) {
       }
       readAsync = /* @__PURE__ */ __name(async (url) => {
         if (isFileURI(url)) {
-          return new Promise((resolve3, reject) => {
+          return new Promise((resolve2, reject) => {
             var xhr = new XMLHttpRequest();
             xhr.open("GET", url, true);
             xhr.responseType = "arraybuffer";
             xhr.onload = () => {
               if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                resolve3(xhr.response);
+                resolve2(xhr.response);
                 return;
               }
               reject(xhr.status);
@@ -1836,9 +1777,9 @@ async function Module2(moduleArg = {}) {
     __name(receiveInstantiationResult, "receiveInstantiationResult");
     var info2 = getWasmImports();
     if (Module["instantiateWasm"]) {
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve2, reject) => {
         Module["instantiateWasm"](info2, (mod, inst) => {
-          resolve3(receiveInstance(mod, inst));
+          resolve2(receiveInstance(mod, inst));
         });
       });
     }
@@ -3169,8 +3110,8 @@ async function Module2(moduleArg = {}) {
   if (runtimeInitialized) {
     moduleRtn = Module;
   } else {
-    moduleRtn = new Promise((resolve3, reject) => {
-      readyPromiseResolve = resolve3;
+    moduleRtn = new Promise((resolve2, reject) => {
+      readyPromiseResolve = resolve2;
       readyPromiseReject = reject;
     });
   }
@@ -4032,32 +3973,14 @@ var Query = class {
 };
 
 // src/code-query/parser.ts
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
 var localRequire = createRequire(import.meta.url);
-var EXT_TO_GRAMMAR = {
-  ".ts": "typescript",
-  ".mts": "typescript",
-  ".cts": "typescript",
-  ".tsx": "tsx",
-  ".js": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".jsx": "javascript",
-  ".py": "python",
-  ".pyi": "python",
-  ".go": "go",
-  ".rs": "rust",
-  ".java": "java"
-};
 var parserInitPromise = null;
 var languageCache = /* @__PURE__ */ new Map();
 var resolvedGrammarDir = null;
-function grammarForPath(filePath) {
-  const lower = filePath.toLowerCase();
-  for (const ext of Object.keys(EXT_TO_GRAMMAR)) {
-    if (lower.endsWith(ext)) return EXT_TO_GRAMMAR[ext];
-  }
-  return null;
-}
 async function getParser(grammar, opts = {}) {
   if (!parserInitPromise) {
     parserInitPromise = Parser.init({
@@ -4107,1095 +4030,8 @@ var DEV_PACKAGE_FOR_GRAMMAR = {
   java: ["tree-sitter-java"]
 };
 
-// src/code-query/find-in-code.ts
-var IDENTIFIER_TYPES = /* @__PURE__ */ new Set([
-  "identifier",
-  "property_identifier",
-  "type_identifier",
-  "shorthand_property_identifier",
-  "shorthand_property_identifier_pattern",
-  "field_identifier",
-  "package_identifier"
-]);
-var DECLARATION_NAME_PARENTS = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "function_signature",
-  "class_declaration",
-  "interface_declaration",
-  "type_alias_declaration",
-  "enum_declaration",
-  "method_definition",
-  "method_signature",
-  "abstract_method_signature",
-  "public_field_definition",
-  "field_definition",
-  "property_signature",
-  "internal_module",
-  "variable_declarator",
-  "function_definition",
-  "class_definition",
-  "method_declaration",
-  "type_spec",
-  "function_item",
-  "struct_item",
-  "enum_item",
-  "trait_item",
-  "type_item",
-  "mod_item",
-  "const_item",
-  "static_item",
-  "constructor_declaration"
-]);
-var CALL_PARENT_TYPES = /* @__PURE__ */ new Set([
-  "call_expression",
-  "new_expression",
-  "call",
-  "method_invocation",
-  "object_creation_expression"
-]);
-var MEMBER_PARENT_TYPES = /* @__PURE__ */ new Set([
-  "member_expression",
-  "attribute",
-  "selector_expression",
-  "field_expression"
-]);
-var CALLEE_FIELDS = ["function", "constructor", "name"];
-var MEMBER_NAME_FIELDS = ["property", "field", "attribute", "name"];
-async function findInCode(filePath, source, name2, opts = {}) {
-  if (!name2) return [];
-  const grammar = grammarForPath(filePath);
-  if (!grammar) return [];
-  const parser = await getParser(grammar);
-  try {
-    const tree = parser.parse(source);
-    if (!tree) return [];
-    try {
-      const sourceLines = source.split(/\r?\n/);
-      const matches = [];
-      walk(tree.rootNode, (node) => {
-        if (!IDENTIFIER_TYPES.has(node.type)) return;
-        if (node.text !== name2) return;
-        const kind = classify(node);
-        const filter = opts.kind ?? "any";
-        if (filter !== "any" && filter !== kind) return;
-        const line = node.startPosition.row + 1;
-        const column = node.startPosition.column + 1;
-        matches.push({
-          line,
-          column,
-          kind,
-          snippet: sourceLines[node.startPosition.row] ?? ""
-        });
-      });
-      return matches;
-    } finally {
-      tree.delete();
-    }
-  } finally {
-    parser.delete();
-  }
-}
-function classify(node) {
-  const parent = node.parent;
-  if (!parent) return "reference";
-  if (DECLARATION_NAME_PARENTS.has(parent.type)) {
-    const nameField = parent.childForFieldName("name");
-    if (nameField && nameField.id === node.id) return "definition";
-  }
-  if (CALL_PARENT_TYPES.has(parent.type) && fieldMatches(parent, node, CALLEE_FIELDS)) {
-    return "call";
-  }
-  if (MEMBER_PARENT_TYPES.has(parent.type) && fieldMatches(parent, node, MEMBER_NAME_FIELDS)) {
-    const grandparent = parent.parent;
-    if (grandparent && CALL_PARENT_TYPES.has(grandparent.type) && fieldMatches(grandparent, parent, CALLEE_FIELDS)) {
-      return "call";
-    }
-  }
-  return "reference";
-}
-function fieldMatches(parent, child, fields) {
-  for (const field of fields) {
-    const f = parent.childForFieldName(field);
-    if (f && f.id === child.id) return true;
-  }
-  return false;
-}
-function walk(root, visit) {
-  const cursor = root.walk();
-  try {
-    let visitedChildren = false;
-    while (true) {
-      if (!visitedChildren) visit(cursor.currentNode);
-      if (!visitedChildren && cursor.gotoFirstChild()) continue;
-      if (cursor.gotoNextSibling()) {
-        visitedChildren = false;
-        continue;
-      }
-      if (!cursor.gotoParent()) return;
-      visitedChildren = true;
-    }
-  } finally {
-    cursor.delete();
-  }
-}
-
-// src/code-query/symbols.ts
-var TS_QUERY = `
-(function_declaration name: (identifier) @name) @function
-(class_declaration name: (type_identifier) @name) @class
-(interface_declaration name: (type_identifier) @name) @interface
-(type_alias_declaration name: (type_identifier) @name) @type
-(enum_declaration name: (identifier) @name) @enum
-(method_definition name: (property_identifier) @name) @method
-(public_field_definition name: (property_identifier) @name) @property
-(variable_declarator name: (identifier) @name value: [(arrow_function) (function_expression)]) @function
-(internal_module name: (identifier) @name) @namespace
-`;
-var JS_QUERY = `
-(function_declaration name: (identifier) @name) @function
-(class_declaration name: (identifier) @name) @class
-(method_definition name: (property_identifier) @name) @method
-(field_definition property: (property_identifier) @name) @property
-(variable_declarator name: (identifier) @name value: [(arrow_function) (function_expression)]) @function
-`;
-var PYTHON_QUERY = `
-(function_definition name: (identifier) @name) @function
-(class_definition name: (identifier) @name) @class
-`;
-var GO_QUERY = `
-(function_declaration name: (identifier) @name) @function
-(method_declaration name: (field_identifier) @name) @method
-(type_spec name: (type_identifier) @name type: (struct_type)) @class
-(type_spec name: (type_identifier) @name type: (interface_type)) @interface
-(type_spec name: (type_identifier) @name) @type
-`;
-var RUST_QUERY = `
-(function_item name: (identifier) @name) @function
-(struct_item name: (type_identifier) @name) @class
-(enum_item name: (type_identifier) @name) @enum
-(trait_item name: (type_identifier) @name) @interface
-(type_item name: (type_identifier) @name) @type
-(mod_item name: (identifier) @name) @namespace
-(const_item name: (identifier) @name) @property
-(static_item name: (identifier) @name) @property
-`;
-var JAVA_QUERY = `
-(class_declaration name: (identifier) @name) @class
-(interface_declaration name: (identifier) @name) @interface
-(enum_declaration name: (identifier) @name) @enum
-(method_declaration name: (identifier) @name) @method
-(constructor_declaration name: (identifier) @name) @method
-(field_declaration declarator: (variable_declarator name: (identifier) @name)) @property
-`;
-var QUERIES = {
-  typescript: TS_QUERY,
-  tsx: TS_QUERY,
-  javascript: JS_QUERY,
-  python: PYTHON_QUERY,
-  go: GO_QUERY,
-  rust: RUST_QUERY,
-  java: JAVA_QUERY
-};
-var KIND_CAPTURE_NAMES = /* @__PURE__ */ new Set([
-  "function",
-  "class",
-  "interface",
-  "type",
-  "enum",
-  "method",
-  "property",
-  "namespace"
-]);
-var PARENT_CONTAINER_TYPES = /* @__PURE__ */ new Set([
-  "class_declaration",
-  "interface_declaration",
-  "internal_module",
-  "class_definition",
-  "impl_item",
-  "trait_item",
-  "mod_item"
-]);
-var METHOD_PROMOTING_CONTAINER_TYPES = /* @__PURE__ */ new Set([
-  "class_declaration",
-  "class_definition",
-  "interface_declaration",
-  "impl_item",
-  "trait_item"
-]);
-async function extractSymbols(filePath, source) {
-  const grammar = grammarForPath(filePath);
-  if (!grammar) return [];
-  const parser = await getParser(grammar);
-  try {
-    const tree = parser.parse(source);
-    if (!tree) return [];
-    const language = parser.language;
-    if (!language) return [];
-    const query = new Query(language, QUERIES[grammar]);
-    try {
-      const matches = query.matches(tree.rootNode);
-      return matchesToSymbols(matches);
-    } finally {
-      query.delete();
-      tree.delete();
-    }
-  } finally {
-    parser.delete();
-  }
-}
-function matchesToSymbols(matches) {
-  const out2 = [];
-  for (const match of matches) {
-    let nameNode = null;
-    let containerNode = null;
-    let kind = null;
-    for (const cap of match.captures) {
-      if (cap.name === "name") {
-        nameNode = cap.node;
-      } else if (KIND_CAPTURE_NAMES.has(cap.name)) {
-        containerNode = cap.node;
-        kind = cap.name;
-      }
-    }
-    if (!nameNode || !containerNode || !kind) continue;
-    const enclosing = findEnclosingContainer(containerNode);
-    if (kind === "function" && enclosing && METHOD_PROMOTING_CONTAINER_TYPES.has(enclosing.type)) {
-      kind = "method";
-    }
-    out2.push({
-      name: nameNode.text,
-      kind,
-      line: containerNode.startPosition.row + 1,
-      column: containerNode.startPosition.column + 1,
-      endLine: containerNode.endPosition.row + 1,
-      endColumn: containerNode.endPosition.column + 1,
-      parent: enclosing ? containerNameOf(enclosing) : void 0
-    });
-  }
-  out2.sort((a, b) => a.line - b.line || a.column - b.column);
-  return out2;
-}
-function findEnclosingContainer(node) {
-  let current = node.parent;
-  while (current) {
-    if (PARENT_CONTAINER_TYPES.has(current.type)) return current;
-    current = current.parent;
-  }
-  return null;
-}
-function containerNameOf(container) {
-  if (container.type === "impl_item") {
-    const typeField = container.childForFieldName("type");
-    if (typeField) return typeField.text;
-  }
-  const nameField = container.childForFieldName("name");
-  return nameField?.text;
-}
-
-// src/tools/code-query.ts
-var UNSUPPORTED = "language not supported (TS/TSX/JS/JSX/Python/Go/Rust/Java); use search_content for grep-style matching";
-function registerCodeQueryTools(registry, opts) {
-  const { rootDir } = opts;
-  registry.register({
-    name: "get_symbols",
-    description: "Outline a single TS/TSX/JS/JSX/Python/Go/Rust/Java file via tree-sitter \u2014 returns its top-level + nested symbols (functions, classes, methods, interfaces, types, enums, namespaces) with 1-based line/column. Grammar-aware, ignores names inside comments/strings. Use for 'what's in this file' / 'where is X defined here'; for cross-file scans use search_content. Result: {path, symbols:[{name, kind, line, column, endLine, endColumn, parent?}]} or {path, error}.",
-    readOnly: true,
-    parallelSafe: true,
-    stormExempt: true,
-    parameters: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "File path (relative to project root or absolute)."
-        }
-      },
-      required: ["path"]
-    },
-    fn: async (args2) => {
-      const filePath = resolveProjectPath(rootDir, args2.path);
-      if (!grammarForPath(filePath)) {
-        return JSON.stringify({ path: args2.path, error: UNSUPPORTED });
-      }
-      const source = await readFile(filePath, "utf8");
-      const symbols = await extractSymbols(filePath, source);
-      return JSON.stringify({ path: args2.path, symbols });
-    }
-  });
-  registry.register({
-    name: "find_in_code",
-    description: "Find an identifier `name` in a single TS/TSX/JS/JSX/Python/Go/Rust/Java file, AST-filtered \u2014 skips matches inside comments and strings. Optional `kind` narrows by syntactic role: 'call' (function call site), 'definition' (declaration name), 'reference' (other uses), 'any' (default). Within-file only \u2014 does NOT resolve cross-file references; use search_content + reading for that. Result: {path, matches:[{line, column, kind, snippet}]} or {path, error}.",
-    readOnly: true,
-    parallelSafe: true,
-    stormExempt: true,
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "Exact identifier text to find."
-        },
-        path: {
-          type: "string",
-          description: "File path (relative to project root or absolute)."
-        },
-        kind: {
-          type: "string",
-          enum: ["any", "call", "definition", "reference"],
-          description: "Filter by syntactic role. Default 'any'."
-        }
-      },
-      required: ["name", "path"]
-    },
-    fn: async (args2) => {
-      const filePath = resolveProjectPath(rootDir, args2.path);
-      if (!grammarForPath(filePath)) {
-        return JSON.stringify({ path: args2.path, error: UNSUPPORTED });
-      }
-      const source = await readFile(filePath, "utf8");
-      const kind = args2.kind ?? "any";
-      const findOpts = kind === "any" ? {} : { kind };
-      const matches = await findInCode(filePath, source, args2.name, findOpts);
-      return JSON.stringify({ path: args2.path, matches });
-    }
-  });
-}
-function resolveProjectPath(rootDir, raw) {
-  const stripped = raw.replace(/^[/\\]+/, "");
-  return pathResolve(rootDir, stripped.length === 0 ? "." : stripped);
-}
-
-// src/java/class-source-finder.ts
-import { execFile } from "child_process";
-import * as fs3 from "fs";
-import * as fsp from "fs/promises";
-import * as os from "os";
-import * as path from "path";
-
-// src/java/zip-reader.ts
-import * as fs2 from "fs";
-import * as zlib from "zlib";
-var EOCD_SIGNATURE = 101010256;
-var CENTRAL_DIR_SIGNATURE = 33639248;
-var LOCAL_FILE_SIGNATURE = 67324752;
-var EOCD_MIN_SIZE = 22;
-var EOCD_MAX_COMMENT = 65535;
-var COMPRESSION_STORED = 0;
-var COMPRESSION_DEFLATED = 8;
-function readU32LE(buf, offset) {
-  return buf.readUInt32LE(offset);
-}
-function readU16LE(buf, offset) {
-  return buf.readUInt16LE(offset);
-}
-function findEOCD(fd, fileSize) {
-  const searchStart = Math.max(0, fileSize - EOCD_MAX_COMMENT - EOCD_MIN_SIZE);
-  let chunkOffset = fileSize;
-  while (chunkOffset > searchStart) {
-    const readSize = Math.min(1024, chunkOffset - searchStart);
-    chunkOffset -= readSize;
-    const buf = Buffer.alloc(readSize);
-    fs2.readSync(fd, buf, 0, readSize, chunkOffset);
-    for (let i2 = readSize - 4; i2 >= 0; i2--) {
-      if (buf.readUInt32LE(i2) === EOCD_SIGNATURE) {
-        const eocdOffset = chunkOffset + i2;
-        const eocdSize = Math.min(EOCD_MIN_SIZE + EOCD_MAX_COMMENT, fileSize - eocdOffset);
-        const eocdBuf = Buffer.alloc(eocdSize);
-        fs2.readSync(fd, eocdBuf, 0, eocdSize, eocdOffset);
-        return { offset: eocdOffset, buf: eocdBuf };
-      }
-    }
-  }
-  throw new Error("Not a valid ZIP file: EOCD signature not found");
-}
-function parseCentralDirectory(fd, eocdBuf) {
-  const centralDirOffset = readU32LE(eocdBuf, 16);
-  const totalEntries = readU16LE(eocdBuf, 10);
-  const entries = [];
-  let offset = centralDirOffset;
-  for (let i2 = 0; i2 < totalEntries; i2++) {
-    const headerBuf = Buffer.alloc(46);
-    fs2.readSync(fd, headerBuf, 0, 46, offset);
-    if (readU32LE(headerBuf, 0) !== CENTRAL_DIR_SIGNATURE) {
-      throw new Error(`Corrupt central directory at offset ${offset}`);
-    }
-    const compressionMethod = readU16LE(headerBuf, 10);
-    const compressedSize = readU32LE(headerBuf, 20);
-    const uncompressedSize = readU32LE(headerBuf, 24);
-    const fileNameLen = readU16LE(headerBuf, 28);
-    const extraLen = readU16LE(headerBuf, 30);
-    const commentLen = readU16LE(headerBuf, 32);
-    const localHeaderOffset = readU32LE(headerBuf, 42);
-    const nameBuf = Buffer.alloc(fileNameLen);
-    fs2.readSync(fd, nameBuf, 0, fileNameLen, offset + 46);
-    const fileName = nameBuf.toString("utf8");
-    entries.push({
-      fileName,
-      compressionMethod,
-      compressedSize,
-      uncompressedSize,
-      localHeaderOffset
-    });
-    offset += 46 + fileNameLen + extraLen + commentLen;
-  }
-  return entries;
-}
-function readJarEntry(jarPath, entryName) {
-  const fd = fs2.openSync(jarPath, "r");
-  try {
-    const stat = fs2.fstatSync(fd);
-    const fileSize = stat.size;
-    const eocd = findEOCD(fd, fileSize);
-    const entries = parseCentralDirectory(fd, eocd.buf);
-    const target = entries.find((e) => e.fileName === entryName);
-    if (!target) return null;
-    const localHeaderBuf = Buffer.alloc(30);
-    fs2.readSync(fd, localHeaderBuf, 0, 30, target.localHeaderOffset);
-    if (readU32LE(localHeaderBuf, 0) !== LOCAL_FILE_SIGNATURE) {
-      throw new Error(`Corrupt local file header at offset ${target.localHeaderOffset}`);
-    }
-    const localFileNameLen = readU16LE(localHeaderBuf, 26);
-    const localExtraLen = readU16LE(localHeaderBuf, 28);
-    const dataOffset = target.localHeaderOffset + 30 + localFileNameLen + localExtraLen;
-    const compressedBuf = Buffer.alloc(target.compressedSize);
-    fs2.readSync(fd, compressedBuf, 0, target.compressedSize, dataOffset);
-    let data;
-    if (target.compressionMethod === COMPRESSION_STORED) {
-      data = compressedBuf;
-    } else if (target.compressionMethod === COMPRESSION_DEFLATED) {
-      data = zlib.inflateRawSync(compressedBuf);
-    } else {
-      throw new Error(
-        `Unsupported compression method ${target.compressionMethod} for entry "${entryName}"`
-      );
-    }
-    return { fileName: target.fileName, data };
-  } finally {
-    fs2.closeSync(fd);
-  }
-}
-
-// src/java/class-source-finder.ts
-var ClassSourceFinder = class _ClassSourceFinder {
-  projectRoot;
-  repoPaths;
-  javapCommand;
-  maxJarScan;
-  signal;
-  static defaultRepoPaths() {
-    const home = os.homedir();
-    const candidates = [path.join(home, ".m2", "repository"), path.join(home, ".gradle", "caches")];
-    return candidates.filter((p) => fs3.existsSync(p));
-  }
-  constructor(options) {
-    this.projectRoot = path.resolve(options.projectRoot);
-    this.repoPaths = options.repoPaths && options.repoPaths.length > 0 ? options.repoPaths.map((p) => path.resolve(p)) : _ClassSourceFinder.defaultRepoPaths();
-    this.javapCommand = options.javapCommand ?? "javap";
-    this.maxJarScan = options.maxJarScan ?? 2e3;
-    this.signal = options.signal;
-  }
-  async findSource(fullyQualifiedName, options) {
-    this.throwIfAborted();
-    const projectResult = await this.searchProject(fullyQualifiedName);
-    if (projectResult) return projectResult;
-    return this.searchRepositories(fullyQualifiedName, options?.jarKeyword);
-  }
-  async findSourceInJar(fullyQualifiedName, jarPath) {
-    this.throwIfAborted();
-    const resolvedJarPath = path.resolve(jarPath);
-    if (!fs3.existsSync(resolvedJarPath)) {
-      return { found: false, method: "not-found" };
-    }
-    const classEntry = `${fullyQualifiedName.replace(/\./g, "/")}.class`;
-    try {
-      const content = readJarEntry(resolvedJarPath, classEntry);
-      if (!content) return { found: false, method: "not-found" };
-      const source = await this.decompileFromJar(resolvedJarPath, content.data, fullyQualifiedName);
-      return { found: true, source, method: "jar", sourcePath: resolvedJarPath };
-    } catch (err2) {
-      return { found: false, method: "not-found" };
-    }
-  }
-  async searchProject(fqn) {
-    const simpleName = this.simpleClassName(fqn);
-    const suffixes = [`${simpleName}.java`, `${simpleName}.java.txt`];
-    const queue = [this.projectRoot];
-    while (queue.length > 0) {
-      this.throwIfAborted();
-      const dir = queue.shift();
-      let entries;
-      try {
-        entries = await fsp.readdir(dir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "target" || entry.name === "build" || entry.name === "dist" || entry.name === ".idea" || entry.name === ".vscode" || entry.name === ".gradle") {
-            continue;
-          }
-          queue.push(fullPath);
-        } else if (entry.isFile()) {
-          if (suffixes.includes(entry.name)) {
-            const source = await fsp.readFile(fullPath, "utf-8");
-            return { found: true, source, method: "project", sourcePath: fullPath };
-          }
-        }
-      }
-    }
-    return null;
-  }
-  async searchRepositories(fqn, jarKeyword) {
-    const javaEntry = `${fqn.replace(/\./g, "/")}.java`;
-    const classEntry = `${fqn.replace(/\./g, "/")}.class`;
-    const sourceJars = [];
-    const regularJars = [];
-    for (const repoDir of this.repoPaths) {
-      await this.walkForJars(repoDir, sourceJars, regularJars, jarKeyword);
-    }
-    for (const jarPath of sourceJars) {
-      this.throwIfAborted();
-      try {
-        const content = readJarEntry(jarPath, javaEntry);
-        if (content) {
-          return {
-            found: true,
-            source: content.data.toString("utf-8"),
-            method: "m2-source-jar",
-            sourcePath: jarPath
-          };
-        }
-      } catch {
-      }
-    }
-    let scanned = 0;
-    for (const jarPath of regularJars) {
-      this.throwIfAborted();
-      if (scanned >= this.maxJarScan) break;
-      scanned++;
-      try {
-        const content = readJarEntry(jarPath, classEntry);
-        if (content) {
-          const source = await this.decompileFromJar(jarPath, content.data, fqn);
-          return { found: true, source, method: "m2-jar", sourcePath: jarPath };
-        }
-      } catch {
-      }
-    }
-    return { found: false, method: "not-found" };
-  }
-  static MAX_WALK_DEPTH = 64;
-  async walkForJars(dir, sourceJars, regularJars, keyword, depth = 0) {
-    if (depth >= _ClassSourceFinder.MAX_WALK_DEPTH) return;
-    let entries;
-    try {
-      entries = await fsp.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      this.throwIfAborted();
-      if (sourceJars.length + regularJars.length >= this.maxJarScan) return;
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await this.walkForJars(fullPath, sourceJars, regularJars, keyword, depth + 1);
-      } else if (entry.isFile() && entry.name.endsWith(".jar")) {
-        if (!keyword || fullPath.toLowerCase().includes(keyword.toLowerCase())) {
-          if (entry.name.endsWith("-sources.jar") || entry.name.includes("-sources-")) {
-            sourceJars.push(fullPath);
-          } else {
-            regularJars.push(fullPath);
-          }
-        }
-      }
-    }
-  }
-  async decompileFromJar(jarPath, classBytes, fqn) {
-    const tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), "reasonix-java-src-"));
-    try {
-      const pkgPath = fqn.replace(/\./g, path.sep);
-      const classDir = path.join(tmpDir, path.dirname(pkgPath));
-      await fsp.mkdir(classDir, { recursive: true });
-      const classFile = path.join(tmpDir, `${pkgPath}.class`);
-      await fsp.writeFile(classFile, classBytes);
-      const raw = await this.runJavap(fqn, tmpDir);
-      return _ClassSourceFinder.compressJavapOutput(raw);
-    } finally {
-      await fsp.rm(tmpDir, { recursive: true, force: true }).catch(() => {
-      });
-    }
-  }
-  // Strip constant pool, debug tables (LineNumberTable / LocalVariableTable /
-  // StackMapTable), and "Compiled from …" from javap output — cuts ~60-80% of
-  // tokens for AI consumption while keeping method sigs + bytecode.
-  static compressJavapOutput(raw) {
-    const lines = raw.split("\n");
-    const out2 = [];
-    let skipUntilIndent = null;
-    for (const line of lines) {
-      if (/^\s+#\d+\s*=/.test(line)) continue;
-      if (skipUntilIndent !== null) {
-        const m = line.match(/^(\s*)/);
-        const indent = m?.[1]?.length ?? 0;
-        if (indent > skipUntilIndent) continue;
-        skipUntilIndent = null;
-        if (line.trim() === "") continue;
-      }
-      const debugMatch = line.match(/^(\s+)(LineNumberTable|LocalVariableTable|StackMapTable):/);
-      if (debugMatch) {
-        skipUntilIndent = debugMatch[1].length;
-        continue;
-      }
-      if (line.startsWith("Compiled from ")) continue;
-      out2.push(line);
-    }
-    return out2.join("\n").replace(/\n{3,}/g, "\n\n").trim();
-  }
-  runJavap(className, classPath) {
-    return new Promise((resolve3, reject) => {
-      execFile(
-        this.javapCommand,
-        ["-c", "-p", "-cp", classPath, className],
-        {
-          maxBuffer: 15 * 1024 * 1024,
-          timeout: 3e4,
-          signal: this.signal
-        },
-        (err2, stdout, stderr) => {
-          if (err2) {
-            const msg = [stdout, stderr].filter(Boolean).join("\n") || err2.message;
-            reject(new Error(`javap failed: ${msg}`));
-            return;
-          }
-          resolve3(stdout);
-        }
-      );
-    });
-  }
-  simpleClassName(fqn) {
-    const lastDot = fqn.lastIndexOf(".");
-    return lastDot === -1 ? fqn : fqn.slice(lastDot + 1);
-  }
-  throwIfAborted() {
-    if (this.signal?.aborted) {
-      throw new DOMException("Aborted", "AbortError");
-    }
-  }
-};
-
-// src/tools/java-source.ts
-function registerJavaSourceTool(registry, opts = {}) {
-  registry.register({
-    name: "java_source",
-    description: [
-      "Find and return Java source code by fully-qualified class name.",
-      "",
-      "Search mode: walk the project tree for a `.java` file, then scan `~/.m2/repository` jars whose filename or path contains `jarKeyword`.",
-      "",
-      "Returns the source text (or decompiled bytecode) on success, or a clear 'not found' message.",
-      "Only call this tool once per class name \u2014 it's I/O heavy."
-    ].join("\n"),
-    readOnly: true,
-    parameters: {
-      type: "object",
-      properties: {
-        className: {
-          type: "string",
-          description: 'Fully qualified Java class name, e.g. "com.google.common.collect.Lists" or "org.springframework.web.servlet.DispatcherServlet".'
-        },
-        jarKeyword: {
-          type: "string",
-          description: 'Only search jars whose filename or path contains this keyword (case-insensitive). Keep it short \u2014 a narrow substring like "spring-core", "guava", or "mycompany-utils" scans faster and matches more precisely than a long fragment.'
-        }
-      },
-      required: ["className", "jarKeyword"]
-    },
-    parallelSafe: true,
-    fn: async (args2) => {
-      const className = (args2?.className ?? "").trim();
-      if (!className) {
-        throw new Error("java_source: `className` is required");
-      }
-      if (!/^[a-zA-Z_$][\w$]*(\.[a-zA-Z_$][\w$]*)*$/.test(className)) {
-        throw new Error(
-          `java_source: "${className}" is not a valid fully qualified Java class name. Expected format: \`com.example.MyClass\``
-        );
-      }
-      const jarKeyword = args2.jarKeyword.trim();
-      if (!jarKeyword) {
-        throw new Error("java_source: `jarKeyword` must not be empty");
-      }
-      const projectRoot = opts.projectRoot || process.cwd();
-      const finder = new ClassSourceFinder({ projectRoot });
-      const result = await finder.findSource(className, { jarKeyword });
-      if (!result.found) {
-        const keywordLine = `  \u2022 Maven .m2 / Gradle cache for jars containing keyword "${jarKeyword}"`;
-        const tip = "Try a different keyword, or check if the class is in a different library.";
-        return JSON.stringify({
-          status: "not-found",
-          className,
-          message: `No source found for "${className}". Searched:
-  \u2022 ${projectRoot}/ for matching .java files
-  ${keywordLine}
-
-${tip}`
-        });
-      }
-      return JSON.stringify({
-        status: "found",
-        className,
-        method: result.method,
-        sourcePath: result.sourcePath,
-        source: result.source
-      });
-    }
-  });
-  return registry;
-}
-
-// src/tools/scaffold.ts
-var VALID_SKILL_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
-var VALID_SERVER_NAME = /^[a-zA-Z_][a-zA-Z0-9_-]{0,63}$/;
-var VALID_TOOL_NAME = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
-function registerScaffoldTools(registry, opts = {}) {
-  const configPath = opts.configPath ?? defaultConfigPath();
-  registry.register({
-    name: "create_skill",
-    description: 'Scaffold a SKILL.md the user can later invoke via `/skill <name>`. Frontmatter (description / allowed_tools / run_as / model) is filled from structured args here. Use `run_as: "subagent"` for read-and-synthesize playbooks; default inline appends body to parent log. Refuses to overwrite existing skills.',
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "Identifier \u2014 letters/digits/`_`/`-`/`.`, 1\u201364 chars. Becomes filename + frontmatter `name`."
-        },
-        description: {
-          type: "string",
-          description: 'One-liner for the skills index. Lead with the verb ("Run X and \u2026").'
-        },
-        body: {
-          type: "string",
-          description: "Markdown playbook. Reference tools by name."
-        },
-        scope: {
-          type: "string",
-          enum: ["project", "global"],
-          description: "`project` (default) = workspace .reasonix/skills/; `global` = ~/.reasonix/skills/."
-        },
-        allowed_tools: {
-          type: "array",
-          items: { type: "string" },
-          description: "Optional tool allowlist for `run_as: subagent`. Omit for full inherited toolset."
-        },
-        run_as: {
-          type: "string",
-          enum: ["inline", "subagent"],
-          description: "inline (default) appends body to parent log. subagent spawns isolated child; only final answer returns."
-        },
-        model: {
-          type: "string",
-          enum: ["deepseek-v4-flash", "deepseek-v4-pro"],
-          description: "Subagent model override. Default flash; use pro only when the playbook needs it."
-        }
-      },
-      required: ["name", "description", "body"]
-    },
-    fn: async (args2) => {
-      const name2 = typeof args2.name === "string" ? args2.name.trim() : "";
-      if (!VALID_SKILL_NAME.test(name2)) {
-        return JSON.stringify({
-          error: `invalid skill name: ${JSON.stringify(name2)} \u2014 use letters, digits, _, -, .`
-        });
-      }
-      const description = typeof args2.description === "string" ? args2.description.trim().replace(/\n+/g, " ") : "";
-      if (!description) {
-        return JSON.stringify({
-          error: "create_skill requires a non-empty 'description'"
-        });
-      }
-      const body2 = typeof args2.body === "string" ? args2.body : "";
-      if (!body2.trim()) {
-        return JSON.stringify({ error: "create_skill requires a non-empty 'body'" });
-      }
-      const scope = args2.scope === "global" ? "global" : opts.projectRoot ? "project" : "global";
-      const runAs = args2.run_as === "subagent" ? "subagent" : "inline";
-      const allowedTools = parseAllowedTools(args2.allowed_tools);
-      if (allowedTools && "error" in allowedTools) {
-        return JSON.stringify({ error: allowedTools.error });
-      }
-      const model = typeof args2.model === "string" && args2.model.startsWith("deepseek-") ? args2.model : void 0;
-      const content = serializeSkill({
-        name: name2,
-        description,
-        runAs,
-        allowedTools: allowedTools ?? void 0,
-        model,
-        body: body2
-      });
-      const store = new SkillStore({
-        homeDir: opts.homeDir,
-        projectRoot: opts.projectRoot,
-        customSkillPaths: opts.projectRoot ? loadResolvedSkillPaths(opts.projectRoot, configPath) : []
-      });
-      const result = store.createWithContent(name2, scope, content);
-      if ("error" in result) {
-        return JSON.stringify({ error: result.error });
-      }
-      return JSON.stringify({
-        success: true,
-        path: result.path,
-        scope,
-        name: name2,
-        run_as: runAs
-      });
-    }
-  });
-  registry.register({
-    name: "add_mcp_server",
-    description: 'Register a new MCP server in the user\'s config (`mcp` array). Takes effect next session. Use stdio for local commands, sse/streamable-http for remote. Pass `from_catalog` (e.g. "filesystem", "github") to auto-fill command+args from the bundled catalog. Refuses name collisions.',
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "Namespace prefix on every tool. Letters/digits/`_`/`-`, must start with letter or `_`."
-        },
-        transport: {
-          type: "string",
-          enum: ["stdio", "sse", "streamable-http"],
-          description: "stdio = local command via stdin/stdout; sse / streamable-http = remote. Required unless `from_catalog` is set."
-        },
-        command: {
-          type: "string",
-          description: "Argv[0] for stdio \u2014 typically `npx` or a binary path."
-        },
-        args: {
-          type: "array",
-          items: { type: "string" },
-          description: 'Remaining argv for stdio \u2014 e.g. `["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]`.'
-        },
-        url: {
-          type: "string",
-          description: "Endpoint URL for sse / streamable-http \u2014 must be http(s)://."
-        },
-        from_catalog: {
-          type: "string",
-          description: "Bundled catalog shortcut: filesystem / memory / github / puppeteer / everything. Fills command+args; user supplies user-args via `args`."
-        }
-      },
-      required: ["name"]
-    },
-    fn: async (args2) => {
-      const name2 = typeof args2.name === "string" ? args2.name.trim() : "";
-      if (!VALID_SERVER_NAME.test(name2)) {
-        return JSON.stringify({
-          error: `invalid server name: ${JSON.stringify(name2)} \u2014 must match [a-zA-Z_][a-zA-Z0-9_-]*`
-        });
-      }
-      const specStr = buildSpecString({
-        name: name2,
-        transport: typeof args2.transport === "string" ? args2.transport : void 0,
-        command: typeof args2.command === "string" ? args2.command : void 0,
-        argv: Array.isArray(args2.args) ? args2.args.filter((a) => typeof a === "string") : void 0,
-        url: typeof args2.url === "string" ? args2.url : void 0,
-        fromCatalog: typeof args2.from_catalog === "string" ? args2.from_catalog : void 0
-      });
-      if ("error" in specStr) {
-        return JSON.stringify({ error: specStr.error });
-      }
-      let parsed;
-      try {
-        parsed = parseMcpSpec(specStr.spec);
-      } catch (err2) {
-        return JSON.stringify({ error: err2.message });
-      }
-      if (parsed.transport === "stdio") {
-        try {
-          preflightStdioSpec(parsed);
-        } catch (err2) {
-          return JSON.stringify({ error: err2.message });
-        }
-      }
-      const cfg = readConfig(configPath);
-      const existing = cfg.mcp ?? [];
-      const collision = existing.find((s) => parseSpecName(s) === name2);
-      if (collision) {
-        return JSON.stringify({
-          error: `MCP server ${JSON.stringify(name2)} already registered: ${collision}`
-        });
-      }
-      cfg.mcp = [...existing, specStr.spec];
-      writeConfig(cfg, configPath);
-      return JSON.stringify({
-        success: true,
-        name: name2,
-        transport: parsed.transport,
-        spec: specStr.spec,
-        config_path: configPath,
-        active_on_next_launch: true
-      });
-    }
-  });
-  return registry;
-}
-function serializeSkill(args2) {
-  const lines = ["---", `name: ${args2.name}`, `description: ${args2.description}`];
-  if (args2.runAs === "subagent") {
-    lines.push("runAs: subagent");
-  }
-  if (args2.allowedTools && args2.allowedTools.length > 0) {
-    lines.push(`allowed-tools: ${args2.allowedTools.join(", ")}`);
-  }
-  if (args2.model) {
-    lines.push(`model: ${args2.model}`);
-  }
-  lines.push("---", "");
-  return `${lines.join("\n")}
-${args2.body.trim()}
-`;
-}
-function parseAllowedTools(raw) {
-  if (raw === void 0 || raw === null) return void 0;
-  if (!Array.isArray(raw)) {
-    return { error: "'allowed_tools' must be an array of tool-name strings" };
-  }
-  const out2 = [];
-  for (const v of raw) {
-    if (typeof v !== "string") {
-      return { error: "'allowed_tools' entries must be strings" };
-    }
-    const trimmed = v.trim();
-    if (!trimmed) continue;
-    if (!VALID_TOOL_NAME.test(trimmed)) {
-      return { error: `invalid tool name in allowed_tools: ${JSON.stringify(trimmed)}` };
-    }
-    out2.push(trimmed);
-  }
-  return out2.length > 0 ? out2 : void 0;
-}
-function buildSpecString(input) {
-  if (input.fromCatalog) {
-    const entry = MCP_CATALOG.find((e) => e.name === input.fromCatalog);
-    if (!entry) {
-      const known = MCP_CATALOG.map((e) => e.name).join(", ");
-      return {
-        error: `unknown catalog entry: ${JSON.stringify(input.fromCatalog)} \u2014 known: ${known}`
-      };
-    }
-    const userArgs = input.argv ?? [];
-    if (entry.userArgs && userArgs.length === 0) {
-      return {
-        error: `catalog entry "${entry.name}" needs ${entry.userArgs} \u2014 pass it via the 'args' parameter`
-      };
-    }
-    const tail = userArgs.map(quoteIfNeeded).join(" ");
-    const body2 = `npx -y ${entry.package}${tail ? ` ${tail}` : ""}`;
-    return { spec: `${input.name}=${body2}` };
-  }
-  const transport = input.transport;
-  if (!transport) {
-    return { error: "add_mcp_server requires 'transport' (or 'from_catalog')" };
-  }
-  if (transport === "stdio") {
-    if (!input.command || !input.command.trim()) {
-      return { error: "stdio transport requires 'command'" };
-    }
-    const tail = (input.argv ?? []).map(quoteIfNeeded).join(" ");
-    const body2 = `${quoteIfNeeded(input.command.trim())}${tail ? ` ${tail}` : ""}`;
-    return { spec: `${input.name}=${body2}` };
-  }
-  if (transport === "sse" || transport === "streamable-http") {
-    if (!input.url || !/^https?:\/\//i.test(input.url)) {
-      return { error: `${transport} transport requires an http(s):// 'url'` };
-    }
-    const prefix = transport === "streamable-http" ? "streamable+" : "";
-    return { spec: `${input.name}=${prefix}${input.url.trim()}` };
-  }
-  return { error: `unknown transport: ${JSON.stringify(transport)}` };
-}
-function parseSpecName(spec) {
-  const m = spec.trim().match(/^([a-zA-Z_][a-zA-Z0-9_-]*)=/);
-  return m ? m[1] ?? null : null;
-}
-function quoteIfNeeded(s) {
-  return /\s|"/.test(s) ? `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : s;
-}
-
-// src/code/setup.ts
-function applyPlanMode(tools, editMode) {
-  tools.setPlanMode(editMode === "plan");
-}
-async function buildCodeToolset(opts) {
-  const tools = new ToolRegistry({ rateLimit: loadToolRateLimit() });
-  applyPlanMode(tools, loadEditMode(opts.configPath));
-  const jobs = new JobRegistry();
-  const outlineThresholdBytes = loadFilesystemOutlineThresholdBytes();
-  const registerRooted = (root) => {
-    registerFilesystemTools(tools, { rootDir: root, outlineThresholdBytes });
-    const cfg = readConfig();
-    registerShellTools(tools, {
-      rootDir: root,
-      extraAllowed: () => loadProjectShellAllowed(root),
-      allowAll: () => loadEditMode() === "yolo",
-      jobs,
-      onJobsChanged: opts.onJobsChanged,
-      sensitivePaths: cfg.sensitivePaths
-    });
-    registerMemoryTools(tools, { projectRoot: root });
-    registerCodeQueryTools(tools, { rootDir: root });
-  };
-  const reBootstrapSemantic = async (root) => {
-    const result = await bootstrapSemanticSearchInCodeMode(tools, root);
-    if (!result.enabled) tools.unregister("semantic_search");
-    return result;
-  };
-  registerRooted(opts.rootDir);
-  registerPlanTool(tools);
-  registerChoiceTool(tools);
-  registerTodoTool(tools);
-  registerScaffoldTools(tools, { projectRoot: opts.rootDir });
-  if (searchEnabled()) {
-    registerWebTools(tools);
-  }
-  if (loadJavaSourceEnabled()) {
-    registerJavaSourceTool(tools, { projectRoot: opts.rootDir });
-  }
-  let subagentClient = null;
-  registerSkillTools(tools, {
-    projectRoot: opts.rootDir,
-    customSkillPaths: loadResolvedSkillPaths(opts.rootDir),
-    subagentModels: loadSubagentModels(),
-    onSkillInstalled: opts.onSkillInstalled,
-    subagentRunner: async (skill, task, signal) => {
-      if (!subagentClient) {
-        const ep = loadEndpoint();
-        subagentClient = new DeepSeekClient({ apiKey: ep.apiKey, baseUrl: ep.baseUrl });
-      }
-      const result = await spawnSubagent({
-        client: subagentClient,
-        parentRegistry: tools,
-        parentSignal: signal,
-        system: skill.body,
-        task,
-        model: skill.model,
-        allowedTools: skill.allowedTools,
-        skillName: skill.name,
-        // Late-bound: the TUI's `useSubagent` writes the live callback into
-        // SHARED_SUBAGENT_SINK after mount. Until then `.current` is null
-        // and the events are silently dropped — that's fine for non-TUI
-        // callers (`reasonix chat --transcript`, library use).
-        sink: opts.subagentSink ?? SHARED_SUBAGENT_SINK
-      });
-      return formatSubagentResult(result);
-    }
-  });
-  const semantic = await reBootstrapSemantic(opts.rootDir);
-  return { tools, jobs, registerRooted, reBootstrapSemantic, semantic };
-}
-
 export {
-  applyPlanMode,
-  buildCodeToolset
+  Query,
+  getParser
 };
-//# sourceMappingURL=chunk-IBRTU5WO.js.map
+//# sourceMappingURL=chunk-FP7IOWBQ.js.map