@orquentra/codebuddy 0.0.0-stage → 2.4.0

package/dist/chunk-PQK3GKZH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/indexer/symbols.ts"],"sourcesContent":["import { extname } from \"node:path\";\n\n/**\n * Lightweight symbol extraction (Roadmap N.3). Records the top-level symbols of\n * a TS/JS file, plus class methods as `Class.method` — name, kind, line range,\n * and a one-line signature — using regex\n * + brace matching, deliberately *not* a full parser (consistent with the\n * indexer's \"no fragile parser platform\" stance). This lets context represent a\n * file by its public API (a handful of signatures) instead of its whole body,\n * so an agent can see what a file offers without reading it.\n *\n * It is a heuristic: it targets the common top-level declaration forms and skips\n * anything it can't classify. Deterministic — the same file always yields the\n * same table.\n */\n\nexport type SymbolKind = \"function\" | \"method\" | \"class\" | \"interface\" | \"type\" | \"enum\" | \"const\";\n\nexport type SymbolSpan = {\n  name: string;\n  kind: SymbolKind;\n  /** 1-based inclusive line range. */\n  startLine: number;\n  endLine: number;\n  /** One-line signature (declaration head), truncated. */\n  signature: string;\n  exported: boolean;\n};\n\nconst SYMBOL_CODE_EXTENSIONS = new Set([\".ts\", \".tsx\", \".js\", \".jsx\", \".mjs\", \".cjs\"]);\nconst SIGNATURE_MAX = 120;\nconst SYMBOL_LIMIT = 100;\n\n/** True when a symbol table can be extracted for this path's language. */\nexport function supportsSymbols(path: string): boolean {\n  return SYMBOL_CODE_EXTENSIONS.has(extname(path).toLowerCase());\n}\n\nconst DECLARATION =\n  /^(?<export>export\\s+)?(?<default>default\\s+)?(?<mods>(?:declare\\s+|abstract\\s+|async\\s+)*)(?<kind>function\\*?|class|interface|type|enum|const|let|var)\\s+(?<name>[A-Za-z_$][\\w$]*)/;\n\nexport function extractSymbolTable(content: string): SymbolSpan[] {\n  const lines = content.split(/\\r?\\n/);\n  const symbols: SymbolSpan[] = [];\n\n  for (let index = 0; index < lines.length; index++) {\n    const line = lines[index] ?? \"\";\n    // Top-level only: a declaration that starts at column 0 (optionally exported).\n    if (/^\\s/.test(line)) continue;\n    const match = DECLARATION.exec(line);\n    if (!match?.groups) continue;\n\n    const rawKind = match.groups.kind ?? \"\";\n    const kind = normalizeKind(rawKind);\n    const name = match.groups.name ?? \"\";\n    if (!name) continue;\n\n    const startLine = index + 1;\n    const endLine = findEndLine(lines, index) + 1;\n    const exported = Boolean(match.groups.export);\n    symbols.push({ name, kind, startLine, endLine, signature: buildSignature(line), exported });\n    if (kind === \"class\") symbols.push(...classMethods(lines, index, endLine - 1, name, exported));\n    if (symbols.length >= SYMBOL_LIMIT) break;\n  }\n\n  return symbols.slice(0, SYMBOL_LIMIT);\n}\n\nconst METHOD =\n  /^\\s+(?:(?:public|private|protected|static|abstract|override|async|get|set|readonly)\\s+)*(#?[A-Za-z_$][\\w$]*)\\??(?:<[^>]*>)?\\s*\\(/;\n\n/**\n * Methods directly in a class body (brace depth 1), named `Class.method`, so a\n * task can name a method and get its own span instead of the whole class.\n */\nfunction classMethods(\n  lines: string[],\n  classIndex: number,\n  classEnd: number,\n  className: string,\n  exported: boolean,\n): SymbolSpan[] {\n  const methods: SymbolSpan[] = [];\n  let depth = 0;\n  let parens = 0;\n  let open: { name: string; startLine: number; signature: string } | null = null;\n  for (let index = classIndex; index <= classEnd; index++) {\n    const line = lines[index] ?? \"\";\n    const method: RegExpExecArray | null = depth === 1 && !open ? METHOD.exec(line) : null;\n    if (method?.[1]) {\n      open = {\n        name: `${className}.${method[1]}`,\n        startLine: index + 1,\n        signature: `${className}: ${buildSignature(line.trim())}`,\n      };\n      parens = 0;\n    }\n    const code = codeOnly(line);\n    depth += braceDelta(code);\n    parens += delta(code, \"(\", \")\");\n    // Back at class-body depth after a body, or a bodiless (abstract/overload)\n    // member; an object type in a multi-line parameter list is not the body.\n    if (\n      open &&\n      depth === 1 &&\n      parens <= 0 &&\n      (code.includes(\"}\") || code.trimEnd().endsWith(\";\"))\n    ) {\n      methods.push({ ...open, kind: \"method\", endLine: index + 1, exported });\n      open = null;\n    }\n  }\n  return methods;\n}\n\n/**\n * Render a file's symbols as compact signature lines (the \"symbol capsule\").\n * The signature already preserves a leading `export`, so it is used verbatim.\n */\nexport function symbolSignatures(symbols: SymbolSpan[], limit = 12): string[] {\n  return symbols.slice(0, limit).map((symbol) => symbol.signature);\n}\n\nfunction normalizeKind(raw: string): SymbolKind {\n  if (raw.startsWith(\"function\")) return \"function\";\n  if (raw === \"let\" || raw === \"var\" || raw === \"const\") return \"const\";\n  return raw as SymbolKind;\n}\n\nfunction buildSignature(line: string): string {\n  const head = line.split(\"{\")[0]?.split(\"=>\")[0]?.trimEnd() ?? line.trim();\n  const cleaned = head.replace(/[=;{]\\s*$/, \"\").trim();\n  return cleaned.length <= SIGNATURE_MAX ? cleaned : `${cleaned.slice(0, SIGNATURE_MAX - 1)}…`;\n}\n\n/**\n * Find the last line of a declaration: the first line where both braces and\n * parentheses are balanced, so a multi-line parameter list carries on to its\n * body. A one-line const/type is a single line. Braces in single-line strings\n * and `//` comments are ignored; multi-line template literals, block comments\n * and regex literals can still skew it.\n */\nfunction findEndLine(lines: string[], startIndex: number): number {\n  let braces = 0;\n  let parens = 0;\n  for (let index = startIndex; index < lines.length; index++) {\n    const code = codeOnly(lines[index] ?? \"\");\n    braces += braceDelta(code);\n    parens += delta(code, \"(\", \")\");\n    if (braces <= 0 && parens <= 0) return index;\n  }\n  return lines.length - 1;\n}\n\n/** The line without single-line string literals and a trailing `//` comment. */\nfunction codeOnly(line: string): string {\n  return line.replace(/([\"'`])(?:\\\\.|(?!\\1).)*\\1/g, '\"\"').replace(/\\/\\/.*$/, \"\");\n}\n\nfunction braceDelta(code: string): number {\n  return delta(code, \"{\", \"}\");\n}\n\nfunction delta(code: string, open: string, close: string): number {\n  let total = 0;\n  for (const char of code) {\n    if (char === open) total++;\n    else if (char === close) total--;\n  }\n  return total;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-PYLH4MH5.js

@@ -0,0 +1,34 @@
+// src/hooks/stdio.ts
+async function failSoft(fn) {
+  try {
+    await fn();
+  } catch (error) {
+    process.stderr.write(`codebuddy hook: ${error.message}
+`);
+  }
+}
+function writeStdout(block) {
+  return new Promise((resolveWrite, rejectWrite) => {
+    process.stdout.write(`${block}
+`, (error) => error ? rejectWrite(error) : resolveWrite());
+  });
+}
+async function readHookInput() {
+  if (process.stdin.isTTY) return {};
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export {
+  failSoft,
+  writeStdout,
+  readHookInput
+};
+//# sourceMappingURL=chunk-PYLH4MH5.js.map

package/dist/chunk-PYLH4MH5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/stdio.ts"],"sourcesContent":["/** Hook process I/O shared by every `codebuddy hooks` runtime command. */\nimport type { HookInput } from \"./runtime.js\";\n\nexport async function failSoft(fn: () => Promise<void>): Promise<void> {\n  try {\n    await fn();\n  } catch (error) {\n    process.stderr.write(`codebuddy hook: ${(error as Error).message}\\n`);\n  }\n}\n\n/** Resolves once stdout accepted the data; rejects on EPIPE so delivery is not recorded. */\nexport function writeStdout(block: string): Promise<void> {\n  return new Promise((resolveWrite, rejectWrite) => {\n    process.stdout.write(`${block}\\n`, (error) => (error ? rejectWrite(error) : resolveWrite()));\n  });\n}\n\nexport async function readHookInput(): Promise<HookInput> {\n  if (process.stdin.isTTY) return {};\n  const chunks: Buffer[] = [];\n  for await (const chunk of process.stdin) chunks.push(chunk as Buffer);\n  const raw = Buffer.concat(chunks).toString(\"utf8\").trim();\n  if (!raw) return {};\n  try {\n    return JSON.parse(raw);\n  } catch {\n    return {};\n  }\n}\n"],"mappings":";AAGA,eAAsB,SAAS,IAAwC;AACrE,MAAI;AACF,UAAM,GAAG;AAAA,EACX,SAAS,OAAO;AACd,YAAQ,OAAO,MAAM,mBAAoB,MAAgB,OAAO;AAAA,CAAI;AAAA,EACtE;AACF;AAGO,SAAS,YAAY,OAA8B;AACxD,SAAO,IAAI,QAAQ,CAAC,cAAc,gBAAgB;AAChD,YAAQ,OAAO,MAAM,GAAG,KAAK;AAAA,GAAM,CAAC,UAAW,QAAQ,YAAY,KAAK,IAAI,aAAa,CAAE;AAAA,EAC7F,CAAC;AACH;AAEA,eAAsB,gBAAoC;AACxD,MAAI,QAAQ,MAAM,MAAO,QAAO,CAAC;AACjC,QAAM,SAAmB,CAAC;AAC1B,mBAAiB,SAAS,QAAQ,MAAO,QAAO,KAAK,KAAe;AACpE,QAAM,MAAM,OAAO,OAAO,MAAM,EAAE,SAAS,MAAM,EAAE,KAAK;AACxD,MAAI,CAAC,IAAK,QAAO,CAAC;AAClB,MAAI;AACF,WAAO,KAAK,MAAM,GAAG;AAAA,EACvB,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;","names":[]}

package/dist/chunk-PZ5AY32C.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-PZ5AY32C.js.map

package/dist/chunk-PZ5AY32C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}