@vpxa/kb 0.1.1 → 0.1.2

package/packages/tools/dist/symbol.js

@@ -1,87 +1,3 @@
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function symbol(embedder, store, options) {
-  const { name, limit = 20 } = options;
-  const embedQuery = embedder.embedQuery?.bind(embedder) ?? embedder.embed.bind(embedder);
-  const definitionQuery = [
-    `export function ${name}`,
-    `export class ${name}`,
-    `export const ${name}`,
-    `export interface ${name}`,
-    `export type ${name}`,
-    `export enum ${name}`
-  ].join(" | ");
-  const definitionResults = await store.search(await embedQuery(definitionQuery), {
-    limit: limit * 2
-  });
-  const exportPattern = new RegExp(
-    `^export\\s+(?:default\\s+)?(?:async\\s+)?(?:function|class|const|let|interface|type|enum)\\s+${escapeRegex(name)}\\b`,
-    "m"
-  );
-  let definedIn;
-  for (const result of definitionResults) {
-    if (!exportPattern.test(result.record.content)) continue;
-    const kind = result.record.content.match(/export\s+(?:default\s+)?(?:async\s+)?(\w+)/)?.[1] ?? "unknown";
-    definedIn = {
-      path: result.record.sourcePath,
-      line: result.record.startLine,
-      kind
-    };
-    break;
-  }
-  const importPattern = new RegExp(`import\\s+.*\\b${escapeRegex(name)}\\b.*from\\s+`, "m");
-  const importResults = await store.search(await embedQuery(`import ${name} from`), {
-    limit: limit * 3
-  });
-  const importedBy = [];
-  const seenImports = /* @__PURE__ */ new Set();
-  for (const result of importResults) {
-    const lines = result.record.content.split("\n");
-    for (let index = 0; index < lines.length; index++) {
-      const line = lines[index];
-      if (!importPattern.test(line)) continue;
-      const key = `${result.record.sourcePath}:${line.trim()}`;
-      if (seenImports.has(key)) continue;
-      seenImports.add(key);
-      importedBy.push({
-        path: result.record.sourcePath,
-        line: result.record.startLine + index,
-        importStatement: line.trim()
-      });
-    }
-  }
-  const referencePattern = new RegExp(`\\b${escapeRegex(name)}\\b`);
-  const referenceResults = await store.search(await embedQuery(name), {
-    limit: limit * 3
-  });
-  const referencedIn = [];
-  const seenReferences = /* @__PURE__ */ new Set();
-  for (const result of referenceResults) {
-    if (definedIn && result.record.sourcePath === definedIn.path) continue;
-    const lines = result.record.content.split("\n");
-    for (let index = 0; index < lines.length; index++) {
-      const line = lines[index];
-      if (!referencePattern.test(line) || importPattern.test(line)) continue;
-      const key = `${result.record.sourcePath}:${result.record.startLine + index}`;
-      if (seenReferences.has(key)) continue;
-      seenReferences.add(key);
-      referencedIn.push({
-        path: result.record.sourcePath,
-        line: result.record.startLine + index,
-        context: line.trim().slice(0, 120)
-      });
-      break;
-    }
-  }
-  return {
-    name,
-    definedIn,
-    importedBy: importedBy.slice(0, limit),
-    referencedIn: referencedIn.slice(0, limit)
-  };
-}
-export {
-  symbol
-};
-//# sourceMappingURL=symbol.js.map
+function l(i){return i.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}async function P(i,m,h){const{name:t,limit:s=20}=h,d=i.embedQuery?.bind(i)??i.embed.bind(i),g=[`export function ${t}`,`export class ${t}`,`export const ${t}`,`export interface ${t}`,`export type ${t}`,`export enum ${t}`].join(" | "),x=await m.search(await d(g),{limit:s*2}),I=new RegExp(`^export\\s+(?:default\\s+)?(?:async\\s+)?(?:function|class|const|let|interface|type|enum)\\s+${l(t)}\\b`,"m");let a;for(const e of x){if(!I.test(e.record.content))continue;const r=e.record.content.match(/export\s+(?:default\s+)?(?:async\s+)?(\w+)/)?.[1]??"unknown";a={path:e.record.sourcePath,line:e.record.startLine,kind:r};break}const p=new RegExp(`import\\s+.*\\b${l(t)}\\b.*from\\s+`,"m"),$=await m.search(await d(`import ${t} from`),{limit:s*3}),f=[],u=new Set;for(const e of $){const r=e.record.content.split(`
+`);for(let n=0;n<r.length;n++){const o=r[n];if(!p.test(o))continue;const c=`${e.record.sourcePath}:${o.trim()}`;u.has(c)||(u.add(c),f.push({path:e.record.sourcePath,line:e.record.startLine+n,importStatement:o.trim()}))}}const w=new RegExp(`\\b${l(t)}\\b`),S=await m.search(await d(t),{limit:s*3}),b=[],y=new Set;for(const e of S){if(a&&e.record.sourcePath===a.path)continue;const r=e.record.content.split(`
+`);for(let n=0;n<r.length;n++){const o=r[n];if(!w.test(o)||p.test(o))continue;const c=`${e.record.sourcePath}:${e.record.startLine+n}`;if(!y.has(c)){y.add(c),b.push({path:e.record.sourcePath,line:e.record.startLine+n,context:o.trim().slice(0,120)});break}}}return{name:t,definedIn:a,importedBy:f.slice(0,s),referencedIn:b.slice(0,s)}}export{P as symbol};

package/packages/tools/dist/test-run.js

@@ -1,55 +1,2 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { parseVitest } from "./parse-output.js";
-const execFileAsync = promisify(execFile);
-async function testRun(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const timeout = options.timeout ?? 6e4;
-  const start = Date.now();
-  const args = ["vitest", "run", "--reporter=verbose"];
-  if (options.files?.length) args.push(...options.files);
-  if (options.grep) args.push("--testNamePattern", options.grep);
-  try {
-    const { stdout } = await execFileAsync("npx", args, { cwd, shell: true, timeout });
-    const raw = stdout.toString();
-    const summary = parseVitest(raw);
-    return {
-      summary,
-      passed: summary.failed === 0,
-      raw,
-      durationMs: Date.now() - start
-    };
-  } catch (error) {
-    const raw = getProcessOutput(error);
-    const summary = parseVitest(raw);
-    return {
-      summary,
-      passed: false,
-      raw,
-      durationMs: Date.now() - start
-    };
-  }
-}
-function getProcessOutput(error) {
-  const details = error;
-  const stdout = details.stdout?.toString() ?? "";
-  const stderr = details.stderr?.toString() ?? "";
-  return [stdout, stderr].filter(Boolean).join("\n").trim() || details.message || "Test run failed";
-}
-function classifyExitCode(exitCode, _stdout, command) {
-  if (exitCode === 0) return { isError: false };
-  if (exitCode === 1 && command) {
-    if (/\b(grep|rg|ripgrep|ag|ack|findstr)\b/i.test(command)) {
-      return { isError: false, reason: "grep: no matches (exit 1 is normal)" };
-    }
-    if (/\bdiff\b/i.test(command)) {
-      return { isError: false, reason: "diff: files differ (exit 1 is normal)" };
-    }
-  }
-  return { isError: true };
-}
-export {
-  classifyExitCode,
-  testRun
-};
-//# sourceMappingURL=test-run.js.map
+import{execFile as f}from"node:child_process";import{promisify as c}from"node:util";import{parseVitest as u}from"./parse-output.js";const m=c(f);async function w(r={}){const e=r.cwd??process.cwd(),t=r.timeout??6e4,n=Date.now(),i=["vitest","run","--reporter=verbose"];r.files?.length&&i.push(...r.files),r.grep&&i.push("--testNamePattern",r.grep);try{const{stdout:o}=await m("npx",i,{cwd:e,shell:!0,timeout:t}),s=o.toString(),a=u(s);return{summary:a,passed:a.failed===0,raw:s,durationMs:Date.now()-n}}catch(o){const s=g(o);return{summary:u(s),passed:!1,raw:s,durationMs:Date.now()-n}}}function g(r){const e=r,t=e.stdout?.toString()??"",n=e.stderr?.toString()??"";return[t,n].filter(Boolean).join(`
+`).trim()||e.message||"Test run failed"}function y(r,e,t){if(r===0)return{isError:!1};if(r===1&&t){if(/\b(grep|rg|ripgrep|ag|ack|findstr)\b/i.test(t))return{isError:!1,reason:"grep: no matches (exit 1 is normal)"};if(/\bdiff\b/i.test(t))return{isError:!1,reason:"diff: files differ (exit 1 is normal)"}}return{isError:!0}}export{y as classifyExitCode,w as testRun};

package/packages/tools/dist/text-utils.js

@@ -1,31 +1,2 @@
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function segment(text, strategy) {
-  switch (strategy) {
-    case "paragraph":
-      return text.split(/\n\s*\n/).map((s) => s.trim()).filter((s) => s.length > 0);
-    case "sentence":
-      return text.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
-    case "line":
-      return text.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
-  }
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}
-export {
-  cosineSimilarity,
-  estimateTokens,
-  segment
-};
-//# sourceMappingURL=text-utils.js.map
+function a(e){return Math.ceil(e.length/4)}function o(e,n){switch(n){case"paragraph":return e.split(/\n\s*\n/).map(t=>t.trim()).filter(t=>t.length>0);case"sentence":return e.split(/(?<=[.!?])\s+/).map(t=>t.trim()).filter(t=>t.length>0);case"line":return e.split(`
+`).map(t=>t.trim()).filter(t=>t.length>0)}}function m(e,n){let t=0,i=0,l=0;for(let r=0;r<e.length;r++)t+=e[r]*n[r],i+=e[r]*e[r],l+=n[r]*n[r];const s=Math.sqrt(i)*Math.sqrt(l);return s===0?0:t/s}export{m as cosineSimilarity,a as estimateTokens,o as segment};

package/packages/tools/dist/time-utils.js

@@ -1,135 +1 @@
-function timeUtils(options) {
-  const { operation, input, timezone } = options;
-  switch (operation) {
-    case "now":
-      return formatTimeResult(/* @__PURE__ */ new Date(), timezone);
-    case "parse": {
-      if (!input) throw new Error("input required for parse");
-      return formatTimeResult(parseInput(input), timezone);
-    }
-    case "convert": {
-      if (!input) throw new Error("input required for convert");
-      if (!timezone) throw new Error("timezone required for convert");
-      return formatTimeResult(parseInput(input), timezone);
-    }
-    case "diff": {
-      if (!input) throw new Error("input required for diff (two comma-separated dates)");
-      const parts = input.split(",").map((s) => s.trim());
-      if (parts.length < 2) throw new Error("diff requires two comma-separated dates");
-      const a = parseInput(parts[0]);
-      const b = parseInput(parts[1]);
-      const diffMs = Math.abs(b.getTime() - a.getTime());
-      return {
-        output: formatDuration(diffMs),
-        iso: `PT${Math.floor(diffMs / 1e3)}S`,
-        unix: diffMs,
-        details: {
-          milliseconds: diffMs,
-          seconds: Math.floor(diffMs / 1e3),
-          minutes: Math.floor(diffMs / 6e4),
-          hours: Math.floor(diffMs / 36e5),
-          days: Math.floor(diffMs / 864e5)
-        }
-      };
-    }
-    case "add": {
-      if (!input) throw new Error("input required for add");
-      const { duration } = options;
-      if (!duration) throw new Error('duration required for add (e.g., "2h30m")');
-      const date = parseInput(input);
-      const ms = parseDuration(duration);
-      return formatTimeResult(new Date(date.getTime() + ms), timezone);
-    }
-    default:
-      throw new Error(`Unknown operation: ${operation}`);
-  }
-}
-function parseInput(input) {
-  const num = Number(input);
-  if (!Number.isNaN(num)) {
-    return new Date(num > 1e12 ? num : num * 1e3);
-  }
-  const d = new Date(input);
-  if (Number.isNaN(d.getTime())) throw new Error(`Cannot parse date: ${input}`);
-  return d;
-}
-function formatTimeResult(date, timezone) {
-  const tz = timezone ?? "UTC";
-  const formatted = date.toLocaleString("en-US", {
-    timeZone: tz,
-    dateStyle: "full",
-    timeStyle: "long"
-  });
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone: tz,
-    year: "numeric",
-    month: "numeric",
-    day: "numeric",
-    hour: "numeric",
-    minute: "numeric",
-    second: "numeric",
-    hour12: false
-  }).formatToParts(date).reduce(
-    (acc, part) => {
-      if (part.type !== "literal") acc[part.type] = Number.parseInt(part.value, 10);
-      return acc;
-    },
-    {}
-  );
-  return {
-    output: formatted,
-    iso: date.toISOString(),
-    unix: Math.floor(date.getTime() / 1e3),
-    details: {
-      timezone: tz,
-      year: parts.year,
-      month: parts.month,
-      day: parts.day,
-      hour: parts.hour === 24 ? 0 : parts.hour,
-      minute: parts.minute,
-      second: parts.second
-    }
-  };
-}
-function formatDuration(ms) {
-  const parts = [];
-  const d = Math.floor(ms / 864e5);
-  if (d) parts.push(`${d}d`);
-  const h = Math.floor(ms % 864e5 / 36e5);
-  if (h) parts.push(`${h}h`);
-  const m = Math.floor(ms % 36e5 / 6e4);
-  if (m) parts.push(`${m}m`);
-  const s = Math.floor(ms % 6e4 / 1e3);
-  if (s || parts.length === 0) parts.push(`${s}s`);
-  return parts.join(" ");
-}
-function parseDuration(duration) {
-  let ms = 0;
-  const matches = duration.matchAll(/(\d+)\s*(d|h|m|s|ms)/gi);
-  for (const match of matches) {
-    const val = Number(match[1]);
-    switch (match[2].toLowerCase()) {
-      case "d":
-        ms += val * 864e5;
-        break;
-      case "h":
-        ms += val * 36e5;
-        break;
-      case "m":
-        ms += val * 6e4;
-        break;
-      case "s":
-        ms += val * 1e3;
-        break;
-      case "ms":
-        ms += val;
-        break;
-    }
-  }
-  if (ms === 0) throw new Error(`Cannot parse duration: ${duration}`);
-  return ms;
-}
-export {
-  timeUtils
-};
-//# sourceMappingURL=time-utils.js.map
+function h(o){const{operation:e,input:t,timezone:n}=o;switch(e){case"now":return m(new Date,n);case"parse":{if(!t)throw new Error("input required for parse");return m(u(t),n)}case"convert":{if(!t)throw new Error("input required for convert");if(!n)throw new Error("timezone required for convert");return m(u(t),n)}case"diff":{if(!t)throw new Error("input required for diff (two comma-separated dates)");const r=t.split(",").map(c=>c.trim());if(r.length<2)throw new Error("diff requires two comma-separated dates");const i=u(r[0]),a=u(r[1]),s=Math.abs(a.getTime()-i.getTime());return{output:f(s),iso:`PT${Math.floor(s/1e3)}S`,unix:s,details:{milliseconds:s,seconds:Math.floor(s/1e3),minutes:Math.floor(s/6e4),hours:Math.floor(s/36e5),days:Math.floor(s/864e5)}}}case"add":{if(!t)throw new Error("input required for add");const{duration:r}=o;if(!r)throw new Error('duration required for add (e.g., "2h30m")');const i=u(t),a=d(r);return m(new Date(i.getTime()+a),n)}default:throw new Error(`Unknown operation: ${e}`)}}function u(o){const e=Number(o);if(!Number.isNaN(e))return new Date(e>1e12?e:e*1e3);const t=new Date(o);if(Number.isNaN(t.getTime()))throw new Error(`Cannot parse date: ${o}`);return t}function m(o,e){const t=e??"UTC",n=o.toLocaleString("en-US",{timeZone:t,dateStyle:"full",timeStyle:"long"}),r=new Intl.DateTimeFormat("en-US",{timeZone:t,year:"numeric",month:"numeric",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",hour12:!1}).formatToParts(o).reduce((i,a)=>(a.type!=="literal"&&(i[a.type]=Number.parseInt(a.value,10)),i),{});return{output:n,iso:o.toISOString(),unix:Math.floor(o.getTime()/1e3),details:{timezone:t,year:r.year,month:r.month,day:r.day,hour:r.hour===24?0:r.hour,minute:r.minute,second:r.second}}}function f(o){const e=[],t=Math.floor(o/864e5);t&&e.push(`${t}d`);const n=Math.floor(o%864e5/36e5);n&&e.push(`${n}h`);const r=Math.floor(o%36e5/6e4);r&&e.push(`${r}m`);const i=Math.floor(o%6e4/1e3);return(i||e.length===0)&&e.push(`${i}s`),e.join(" ")}function d(o){let e=0;const t=o.matchAll(/(\d+)\s*(d|h|m|s|ms)/gi);for(const n of t){const r=Number(n[1]);switch(n[2].toLowerCase()){case"d":e+=r*864e5;break;case"h":e+=r*36e5;break;case"m":e+=r*6e4;break;case"s":e+=r*1e3;break;case"ms":e+=r;break}}if(e===0)throw new Error(`Cannot parse duration: ${o}`);return e}export{h as timeUtils};

package/packages/tools/dist/trace.js

@@ -1,114 +1,2 @@
-async function trace(embedder, store, options) {
-  const { start, direction, maxDepth = 3 } = options;
-  const nodes = [];
-  const visitedTargets = /* @__PURE__ */ new Set();
-  const seenNodes = /* @__PURE__ */ new Set();
-  const startVector = await embedder.embed(start);
-  const startResults = await store.search(startVector, { limit: 10 });
-  if (startResults.length === 0) {
-    return { start, direction, nodes, depth: 0 };
-  }
-  const queue = [{ target: start, depth: 0 }];
-  let maxObservedDepth = 0;
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current) break;
-    if (current.depth >= maxDepth) continue;
-    if (visitedTargets.has(current.target)) continue;
-    visitedTargets.add(current.target);
-    const vector = await embedder.embed(current.target);
-    const results = await store.search(vector, { limit: 20 });
-    const escapedTarget = escapeRegExp(current.target);
-    const targetLooksLikeModule = isModuleSpecifier(current.target);
-    for (const result of results) {
-      const lines = result.record.content.split("\n");
-      for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        const lineNum = result.record.startLine + index;
-        const path = result.record.sourcePath;
-        if (direction !== "forward") {
-          const importPattern = targetLooksLikeModule ? new RegExp(`from\\s+['"]${escapedTarget}['"]`) : new RegExp(`import\\s+.*\\b${escapedTarget}\\b.*from\\s+`);
-          if (importPattern.test(line)) {
-            addNode(seenNodes, nodes, {
-              path,
-              symbol: current.target,
-              line: lineNum,
-              relationship: "imported-by"
-            });
-            maxObservedDepth = Math.max(maxObservedDepth, current.depth + 1);
-            const fromMatch = line.match(/from\s+['"]([^'"]+)['"]/);
-            if (!targetLooksLikeModule && fromMatch) {
-              queue.push({ target: fromMatch[1], depth: current.depth + 1 });
-            }
-          }
-        }
-        if (direction !== "backward") {
-          if (targetLooksLikeModule) {
-            const moduleImportPattern = new RegExp(`from\\s+['"]${escapedTarget}['"]`);
-            if (moduleImportPattern.test(line)) {
-              addNode(seenNodes, nodes, {
-                path,
-                symbol: current.target,
-                line: lineNum,
-                relationship: "imports"
-              });
-              maxObservedDepth = Math.max(maxObservedDepth, current.depth + 1);
-            }
-          } else {
-            const callPattern = new RegExp(`\\b${escapedTarget}\\s*\\(`);
-            if (callPattern.test(line) && !/^\s*(?:export\s+)?(?:async\s+)?function\s/.test(line)) {
-              addNode(seenNodes, nodes, {
-                path,
-                symbol: current.target,
-                line: lineNum,
-                relationship: "calls"
-              });
-              maxObservedDepth = Math.max(maxObservedDepth, current.depth + 1);
-            }
-          }
-        }
-        const refPattern = targetLooksLikeModule ? new RegExp(`['"]${escapedTarget}['"]`) : new RegExp(`\\b${escapedTarget}\\b`);
-        if (refPattern.test(line) && !/^\s*import\s/.test(line) && !/^\s*(?:export\s+)?(?:async\s+)?function\s/.test(line)) {
-          addNode(seenNodes, nodes, {
-            path,
-            symbol: current.target,
-            line: lineNum,
-            relationship: "references"
-          });
-          maxObservedDepth = Math.max(maxObservedDepth, current.depth + 1);
-        }
-      }
-    }
-  }
-  return {
-    start,
-    direction,
-    nodes: deduplicateNodes(nodes),
-    depth: maxObservedDepth
-  };
-}
-function addNode(seenNodes, nodes, node) {
-  const key = `${node.path}:${node.line}:${node.relationship}`;
-  if (seenNodes.has(key)) return;
-  seenNodes.add(key);
-  nodes.push(node);
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function isModuleSpecifier(value) {
-  return /[./\\]/.test(value);
-}
-function deduplicateNodes(nodes) {
-  const seen = /* @__PURE__ */ new Set();
-  return nodes.filter((node) => {
-    const key = `${node.path}:${node.line}:${node.relationship}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-export {
-  trace
-};
-//# sourceMappingURL=trace.js.map
+async function v(e,a,r){const{start:s,direction:p,maxDepth:T=3}=r,i=[],x=new Set,d=new Set,R=await e.embed(s);if((await a.search(R,{limit:10})).length===0)return{start:s,direction:p,nodes:i,depth:0};const u=[{target:s,depth:0}];let n=0;for(;u.length>0;){const t=u.shift();if(!t)break;if(t.depth>=T||x.has(t.target))continue;x.add(t.target);const N=await e.embed(t.target),P=await a.search(N,{limit:20}),c=k(t.target),l=E(t.target);for(const b of P){const w=b.record.content.split(`
+`);for(let h=0;h<w.length;h+=1){const o=w[h],m=b.record.startLine+h,f=b.record.sourcePath;if(p!=="forward"&&(l?new RegExp(`from\\s+['"]${c}['"]`):new RegExp(`import\\s+.*\\b${c}\\b.*from\\s+`)).test(o)){g(d,i,{path:f,symbol:t.target,line:m,relationship:"imported-by"}),n=Math.max(n,t.depth+1);const $=o.match(/from\s+['"]([^'"]+)['"]/);!l&&$&&u.push({target:$[1],depth:t.depth+1})}p!=="backward"&&(l?new RegExp(`from\\s+['"]${c}['"]`).test(o)&&(g(d,i,{path:f,symbol:t.target,line:m,relationship:"imports"}),n=Math.max(n,t.depth+1)):new RegExp(`\\b${c}\\s*\\(`).test(o)&&!/^\s*(?:export\s+)?(?:async\s+)?function\s/.test(o)&&(g(d,i,{path:f,symbol:t.target,line:m,relationship:"calls"}),n=Math.max(n,t.depth+1))),(l?new RegExp(`['"]${c}['"]`):new RegExp(`\\b${c}\\b`)).test(o)&&!/^\s*import\s/.test(o)&&!/^\s*(?:export\s+)?(?:async\s+)?function\s/.test(o)&&(g(d,i,{path:f,symbol:t.target,line:m,relationship:"references"}),n=Math.max(n,t.depth+1))}}}return{start:s,direction:p,nodes:M(i),depth:n}}function g(e,a,r){const s=`${r.path}:${r.line}:${r.relationship}`;e.has(s)||(e.add(s),a.push(r))}function k(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function E(e){return/[./\\]/.test(e)}function M(e){const a=new Set;return e.filter(r=>{const s=`${r.path}:${r.line}:${r.relationship}`;return a.has(s)?!1:(a.add(s),!0)})}export{v as trace};

package/packages/tools/dist/truncation.js

@@ -1,45 +1,14 @@
-const HEAD_RATIO = 0.6;
-function headTailTruncate(text, maxLen, headRatio = HEAD_RATIO) {
-  if (text.length <= maxLen) return text;
-  const separatorBudget = 120;
-  const contentBudget = Math.max(0, maxLen - separatorBudget);
-  const headBudget = Math.floor(contentBudget * headRatio);
-  const tailBudget = contentBudget - headBudget;
-  const headRegion = text.slice(0, headBudget);
-  const headCut = headRegion.lastIndexOf("\n");
-  const head = headCut > 0 ? headRegion.slice(0, headCut) : headRegion;
-  const tailStart = text.length - tailBudget;
-  const tailRegion = text.slice(tailStart);
-  const tailCut = tailRegion.indexOf("\n");
-  const tail = tailCut >= 0 ? tailRegion.slice(tailCut + 1) : tailRegion;
-  const omittedChars = text.length - head.length - tail.length;
-  let omittedLines = 1;
-  const omittedStart = head.length;
-  const omittedEnd = text.length - tail.length;
-  for (let i = omittedStart; i < omittedEnd; i++) {
-    if (text.charCodeAt(i) === 10) omittedLines++;
-  }
-  return `${head}
+const T=.6;function m(t,n,c=.6){if(t.length<=n)return t;const o=Math.max(0,n-120),e=Math.floor(o*c),a=o-e,s=t.slice(0,e),h=s.lastIndexOf(`
+`),i=h>0?s.slice(0,h):s,p=t.length-a,l=t.slice(p),d=l.indexOf(`
+`),r=d>=0?l.slice(d+1):l,$=t.length-i.length-r.length;let u=1;const B=i.length,R=t.length-r.length;for(let g=B;g<R;g++)t.charCodeAt(g)===10&&u++;return`${i}
 
-[\u2026 ${omittedLines} lines / ${(omittedChars / 1024).toFixed(1)}KB truncated \u2014 showing first ${head.split("\n").length} + last ${tail.split("\n").length} lines]
+[\u2026 ${u} lines / ${($/1024).toFixed(1)}KB truncated \u2014 showing first ${i.split(`
+`).length} + last ${r.split(`
+`).length} lines]
 
-${tail}`;
-}
-function paragraphTruncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  const searchStart = Math.max(0, maxLen - 200);
-  const searchRegion = text.slice(searchStart, maxLen);
-  const lastBreak = searchRegion.lastIndexOf("\n\n");
-  const cutPoint = lastBreak >= 0 ? searchStart + lastBreak : maxLen;
-  const truncated = text.slice(0, cutPoint).trimEnd();
-  const pct = Math.round(cutPoint / text.length * 100);
-  return `${truncated}
+${r}`}function A(t,n){if(t.length<=n)return t;const c=Math.max(0,n-200),o=t.slice(c,n).lastIndexOf(`
+
+`),e=o>=0?c+o:n,a=t.slice(0,e).trimEnd(),s=Math.round(e/t.length*100);return`${a}
 
 ---
-*[Truncated at ${cutPoint.toLocaleString()} chars \u2014 ${pct}% of original content]*`;
-}
-export {
-  headTailTruncate,
-  paragraphTruncate
-};
-//# sourceMappingURL=truncation.js.map
+*[Truncated at ${e.toLocaleString()} chars \u2014 ${s}% of original content]*`}export{m as headTailTruncate,A as paragraphTruncate};

package/packages/tools/dist/watch.js

@@ -1,61 +1 @@
-import { watch } from "node:fs";
-const watchers = /* @__PURE__ */ new Map();
-const DEFAULT_EXCLUDES = ["node_modules", ".git", "dist", ".turbo", ".kb-data", "cdk.out"];
-function watchStart(options) {
-  const { path: watchPath, maxEvents = 100 } = options;
-  const excludes = options.exclude ?? DEFAULT_EXCLUDES;
-  const id = `watch-${Date.now()}`;
-  const events = [];
-  const shouldExclude = (filePath) => excludes.some((pattern) => normalizePath(filePath).includes(normalizePath(pattern)));
-  const watcher = watch(watchPath, { recursive: true }, (eventType, filename) => {
-    if (filename == null) return;
-    const filePath = String(filename);
-    if (!filePath || shouldExclude(filePath)) return;
-    events.push({
-      type: eventType,
-      path: normalizePath(filePath),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    if (events.length > maxEvents) events.shift();
-  });
-  const handle = {
-    id,
-    path: watchPath,
-    events,
-    status: "watching",
-    stop: () => {
-      watcher.close();
-      handle.status = "stopped";
-      watchers.delete(id);
-    },
-    getEvents: (since) => {
-      if (!since) return events;
-      return events.filter((event) => event.timestamp > since);
-    }
-  };
-  watchers.set(id, { watcher, handle });
-  return handle;
-}
-function watchStop(id) {
-  const entry = watchers.get(id);
-  if (!entry) return false;
-  entry.handle.stop();
-  return true;
-}
-function watchList() {
-  return [...watchers.values()].map((entry) => ({
-    id: entry.handle.id,
-    path: entry.handle.path,
-    status: entry.handle.status,
-    eventCount: entry.handle.events.length
-  }));
-}
-function normalizePath(value) {
-  return value.replace(/\\/g, "/");
-}
-export {
-  watchList,
-  watchStart,
-  watchStop
-};
-//# sourceMappingURL=watch.js.map
+import{watch as g}from"node:fs";const r=new Map,m=["node_modules",".git","dist",".turbo",".kb-data","cdk.out"];function v(t){const{path:s,maxEvents:p=100}=t,d=t.exclude??m,c=`watch-${Date.now()}`,e=[],l=n=>d.some(a=>o(n).includes(o(a))),u=g(s,{recursive:!0},(n,a)=>{if(a==null)return;const h=String(a);!h||l(h)||(e.push({type:n,path:o(h),timestamp:new Date().toISOString()}),e.length>p&&e.shift())}),i={id:c,path:s,events:e,status:"watching",stop:()=>{u.close(),i.status="stopped",r.delete(c)},getEvents:n=>n?e.filter(a=>a.timestamp>n):e};return r.set(c,{watcher:u,handle:i}),i}function w(t){const s=r.get(t);return s?(s.handle.stop(),!0):!1}function x(){return[...r.values()].map(t=>({id:t.handle.id,path:t.handle.path,status:t.handle.status,eventCount:t.handle.events.length}))}function o(t){return t.replace(/\\/g,"/")}export{x as watchList,v as watchStart,w as watchStop};