@vpxa/kb 0.1.1 → 0.1.3

package/packages/tools/dist/batch.js

@@ -1,45 +1 @@
-async function batch(operations, executor, options = {}) {
-  const concurrency = Math.max(1, options.concurrency ?? 4);
-  const results = [];
-  const pending = [...operations];
-  async function runOne(op) {
-    const start = Date.now();
-    try {
-      const result = await executor(op);
-      return {
-        id: op.id,
-        status: "success",
-        result,
-        durationMs: Date.now() - start
-      };
-    } catch (error) {
-      return {
-        id: op.id,
-        status: "error",
-        error: error instanceof Error ? error.message : String(error),
-        durationMs: Date.now() - start
-      };
-    }
-  }
-  while (pending.length > 0) {
-    const chunk = pending.splice(0, concurrency);
-    const chunkResults = await Promise.allSettled(chunk.map((operation) => runOne(operation)));
-    for (const result of chunkResults) {
-      if (result.status === "fulfilled") {
-        results.push(result.value);
-        continue;
-      }
-      results.push({
-        id: "unknown",
-        status: "error",
-        error: result.reason instanceof Error ? result.reason.message : "Promise rejected",
-        durationMs: 0
-      });
-    }
-  }
-  return results;
-}
-export {
-  batch
-};
-//# sourceMappingURL=batch.js.map
+async function h(o,a,c={}){const i=Math.max(1,c.concurrency??4),e=[],s=[...o];async function u(r){const n=Date.now();try{const t=await a(r);return{id:r.id,status:"success",result:t,durationMs:Date.now()-n}}catch(t){return{id:r.id,status:"error",error:t instanceof Error?t.message:String(t),durationMs:Date.now()-n}}}for(;s.length>0;){const r=s.splice(0,i),n=await Promise.allSettled(r.map(t=>u(t)));for(const t of n){if(t.status==="fulfilled"){e.push(t.value);continue}e.push({id:"unknown",status:"error",error:t.reason instanceof Error?t.reason.message:"Promise rejected",durationMs:0})}}return e}export{h as batch};

package/packages/tools/dist/changelog.js

@@ -1,112 +1,2 @@
-import { execSync } from "node:child_process";
-const SAFE_REF = /^[a-zA-Z0-9_./\-~^@{}]+$/;
-function changelog(options) {
-  const {
-    from,
-    to = "HEAD",
-    format = "grouped",
-    includeBreaking = true,
-    cwd = process.cwd()
-  } = options;
-  if (!SAFE_REF.test(from)) throw new Error(`Invalid git ref: ${from}`);
-  if (!SAFE_REF.test(to)) throw new Error(`Invalid git ref: ${to}`);
-  const FIELD = "";
-  const ENTRY = "";
-  const gitFormat = `%H${FIELD}%s${FIELD}%b${FIELD}%an${FIELD}%ai${ENTRY}`;
-  let output;
-  try {
-    output = execSync(`git log "${from}..${to}" --format="${gitFormat}"`, {
-      cwd,
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024
-    });
-  } catch {
-    throw new Error(`Git log failed. Ensure "${from}" and "${to}" are valid refs.`);
-  }
-  const entries = output.split(ENTRY).map((b) => b.trim()).filter(Boolean).map((block) => {
-    const [hash = "", subject = "", body = "", author = "", date = ""] = block.split(FIELD);
-    const m = subject.match(/^(\w+)(?:\(([^)]*)\))?(!)?:\s*(.+)/);
-    return {
-      hash: hash.slice(0, 8),
-      type: m?.[1] ?? "other",
-      scope: m?.[2] ?? "",
-      subject: m?.[4] ?? subject,
-      body: body.trim(),
-      author: author.trim(),
-      date: date.trim().split(" ")[0],
-      breaking: !!(m?.[3] || /BREAKING[\s-]CHANGE/i.test(body))
-    };
-  });
-  const types = {};
-  let breakingCount = 0;
-  for (const e of entries) {
-    types[e.type] = (types[e.type] ?? 0) + 1;
-    if (e.breaking) breakingCount++;
-  }
-  return {
-    entries,
-    markdown: formatChangelog(entries, format, includeBreaking),
-    stats: { total: entries.length, breaking: breakingCount, types }
-  };
-}
-function formatChangelog(entries, format, includeBreaking) {
-  const lines = ["# Changelog", ""];
-  if (includeBreaking) {
-    const breaking = entries.filter((e) => e.breaking);
-    if (breaking.length > 0) {
-      lines.push("## Breaking Changes", "");
-      for (const e of breaking) lines.push(`- ${e.subject} (${e.hash})`);
-      lines.push("");
-    }
-  }
-  if (format === "grouped") {
-    const groups = {};
-    for (const e of entries) {
-      if (!groups[e.type]) groups[e.type] = [];
-      groups[e.type].push(e);
-    }
-    const order = ["feat", "fix", "refactor", "perf", "test", "docs", "chore"];
-    const labels = {
-      feat: "Features",
-      fix: "Bug Fixes",
-      refactor: "Refactoring",
-      perf: "Performance",
-      test: "Tests",
-      docs: "Documentation",
-      chore: "Chores",
-      other: "Other"
-    };
-    for (const type of [...order, ...Object.keys(groups).filter((k) => !order.includes(k))]) {
-      if (!groups[type]?.length) continue;
-      lines.push(`## ${labels[type] ?? type}`, "");
-      for (const e of groups[type]) {
-        const scope = e.scope ? `**${e.scope}:** ` : "";
-        lines.push(`- ${scope}${e.subject} (${e.hash})`);
-      }
-      lines.push("");
-    }
-  } else if (format === "chronological") {
-    for (const e of entries) {
-      const scope = e.scope ? `(${e.scope}) ` : "";
-      lines.push(`- \`${e.date}\` ${e.type}: ${scope}${e.subject} (${e.hash})`);
-    }
-  } else {
-    const byScope = {};
-    for (const e of entries) {
-      const key = e.scope || "general";
-      if (!byScope[key]) byScope[key] = [];
-      byScope[key].push(e);
-    }
-    for (const [scope, scopeEntries] of Object.entries(byScope)) {
-      lines.push(`## ${scope}`, "");
-      for (const e of scopeEntries) lines.push(`- ${e.type}: ${e.subject} (${e.hash})`);
-      lines.push("");
-    }
-  }
-  return lines.join("\n");
-}
-export {
-  changelog,
-  formatChangelog
-};
-//# sourceMappingURL=changelog.js.map
+import{execSync as E}from"node:child_process";const $=/^[a-zA-Z0-9_./\-~^@{}]+$/;function w(i){const{from:a,to:g="HEAD",format:r="grouped",includeBreaking:e=!0,cwd:t=process.cwd()}=i;if(!$.test(a))throw new Error(`Invalid git ref: ${a}`);if(!$.test(g))throw new Error(`Invalid git ref: ${g}`);const n="",o="",s=`%H${n}%s${n}%b${n}%an${n}%ai${o}`;let h;try{h=E(`git log "${a}..${g}" --format="${s}"`,{cwd:t,encoding:"utf8",maxBuffer:10*1024*1024})}catch{throw new Error(`Git log failed. Ensure "${a}" and "${g}" are valid refs.`)}const p=h.split(o).map(c=>c.trim()).filter(Boolean).map(c=>{const[m="",d="",b="",y="",C=""]=c.split(n),f=d.match(/^(\w+)(?:\(([^)]*)\))?(!)?:\s*(.+)/);return{hash:m.slice(0,8),type:f?.[1]??"other",scope:f?.[2]??"",subject:f?.[4]??d,body:b.trim(),author:y.trim(),date:C.trim().split(" ")[0],breaking:!!(f?.[3]||/BREAKING[\s-]CHANGE/i.test(b))}}),l={};let u=0;for(const c of p)l[c.type]=(l[c.type]??0)+1,c.breaking&&u++;return{entries:p,markdown:k(p,r,e),stats:{total:p.length,breaking:u,types:l}}}function k(i,a,g){const r=["# Changelog",""];if(g){const e=i.filter(t=>t.breaking);if(e.length>0){r.push("## Breaking Changes","");for(const t of e)r.push(`- ${t.subject} (${t.hash})`);r.push("")}}if(a==="grouped"){const e={};for(const o of i)e[o.type]||(e[o.type]=[]),e[o.type].push(o);const t=["feat","fix","refactor","perf","test","docs","chore"],n={feat:"Features",fix:"Bug Fixes",refactor:"Refactoring",perf:"Performance",test:"Tests",docs:"Documentation",chore:"Chores",other:"Other"};for(const o of[...t,...Object.keys(e).filter(s=>!t.includes(s))])if(e[o]?.length){r.push(`## ${n[o]??o}`,"");for(const s of e[o]){const h=s.scope?`**${s.scope}:** `:"";r.push(`- ${h}${s.subject} (${s.hash})`)}r.push("")}}else if(a==="chronological")for(const e of i){const t=e.scope?`(${e.scope}) `:"";r.push(`- \`${e.date}\` ${e.type}: ${t}${e.subject} (${e.hash})`)}else{const e={};for(const t of i){const n=t.scope||"general";e[n]||(e[n]=[]),e[n].push(t)}for(const[t,n]of Object.entries(e)){r.push(`## ${t}`,"");for(const o of n)r.push(`- ${o.type}: ${o.subject} (${o.hash})`);r.push("")}}return r.join(`
+`)}export{w as changelog,k as formatChangelog};

package/packages/tools/dist/check.js

@@ -1,59 +1,2 @@
-import { execFile } from "node:child_process";
-import { readFile as readFileAsync } from "node:fs/promises";
-import { join } from "node:path";
-import { promisify } from "node:util";
-import { parseBiome, parseTsc } from "./parse-output.js";
-const execFileAsync = promisify(execFile);
-function getProcessOutput(error) {
-  const candidate = error;
-  const stdout = candidate.stdout?.toString() ?? "";
-  const stderr = candidate.stderr?.toString() ?? "";
-  return [stdout, stderr].filter(Boolean).join("\n").trim() || candidate.message || "Command failed";
-}
-async function check(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const tscResult = { errors: [], passed: true, raw: "" };
-  const biomeResult = { errors: [], passed: true, raw: "" };
-  if (!options.skipTypes) {
-    try {
-      const pkgPath = join(cwd, "package.json");
-      let useProjectScript = false;
-      try {
-        const pkg = JSON.parse(await readFileAsync(pkgPath, "utf-8"));
-        useProjectScript = !!pkg.scripts?.typecheck;
-      } catch {
-      }
-      if (useProjectScript && !options.files?.length) {
-        await execFileAsync("npx", ["turbo", "run", "typecheck"], { cwd, shell: true });
-      } else {
-        const args = ["--noEmit"];
-        if (options.files?.length) args.push(...options.files);
-        await execFileAsync("npx", ["tsc", ...args], { cwd, shell: true });
-      }
-    } catch (error) {
-      tscResult.raw = getProcessOutput(error);
-      tscResult.errors = parseTsc(tscResult.raw);
-      tscResult.passed = tscResult.errors.length === 0;
-    }
-  }
-  if (!options.skipLint) {
-    try {
-      const args = ["check"];
-      if (options.files?.length) args.push(...options.files);
-      await execFileAsync("npx", ["biome", ...args], { cwd, shell: true });
-    } catch (error) {
-      biomeResult.raw = getProcessOutput(error);
-      biomeResult.errors = parseBiome(biomeResult.raw);
-      biomeResult.passed = biomeResult.errors.length === 0;
-    }
-  }
-  return {
-    tsc: tscResult,
-    biome: biomeResult,
-    passed: tscResult.passed && biomeResult.passed
-  };
-}
-export {
-  check
-};
-//# sourceMappingURL=check.js.map
+import{execFile as p}from"node:child_process";import{readFile as l}from"node:fs/promises";import{join as d}from"node:path";import{promisify as f}from"node:util";import{parseBiome as u,parseTsc as g}from"./parse-output.js";const i=f(p);function n(r){const t=r,e=t.stdout?.toString()??"",s=t.stderr?.toString()??"";return[e,s].filter(Boolean).join(`
+`).trim()||t.message||"Command failed"}async function b(r={}){const t=r.cwd??process.cwd(),e={errors:[],passed:!0,raw:""},s={errors:[],passed:!0,raw:""};if(!r.skipTypes)try{const a=d(t,"package.json");let c=!1;try{c=!!JSON.parse(await l(a,"utf-8")).scripts?.typecheck}catch{}if(c&&!r.files?.length)await i("npx",["turbo","run","typecheck"],{cwd:t,shell:!0});else{const o=["--noEmit"];r.files?.length&&o.push(...r.files),await i("npx",["tsc",...o],{cwd:t,shell:!0})}}catch(a){e.raw=n(a),e.errors=g(e.raw),e.passed=e.errors.length===0}if(!r.skipLint)try{const a=["check"];r.files?.length&&a.push(...r.files),await i("npx",["biome",...a],{cwd:t,shell:!0})}catch(a){s.raw=n(a),s.errors=u(s.raw),s.passed=s.errors.length===0}return{tsc:e,biome:s,passed:e.passed&&s.passed}}export{b as check};

package/packages/tools/dist/checkpoint.js

@@ -1,43 +1,2 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-const CHECKPOINT_DIR = ".kb-state/checkpoints";
-function checkpointDir(cwd) {
-  const root = cwd ?? process.cwd();
-  const dir = resolve(root, CHECKPOINT_DIR);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  return dir;
-}
-function checkpointSave(label, data, options) {
-  const slug = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "checkpoint";
-  const checkpoint = {
-    id: `${Date.now()}-${slug}`,
-    label,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    data,
-    files: options?.files,
-    notes: options?.notes
-  };
-  const filePath = resolve(checkpointDir(options?.cwd), `${checkpoint.id}.json`);
-  writeFileSync(filePath, `${JSON.stringify(checkpoint, null, 2)}
-`, "utf-8");
-  return checkpoint;
-}
-function checkpointLoad(id, cwd) {
-  const filePath = resolve(checkpointDir(cwd), `${id}.json`);
-  if (!existsSync(filePath)) return void 0;
-  return JSON.parse(readFileSync(filePath, "utf-8"));
-}
-function checkpointList(cwd) {
-  const dir = checkpointDir(cwd);
-  return readdirSync(dir).filter((file) => file.endsWith(".json")).map((file) => JSON.parse(readFileSync(resolve(dir, file), "utf-8"))).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
-}
-function checkpointLatest(cwd) {
-  return checkpointList(cwd)[0];
-}
-export {
-  checkpointLatest,
-  checkpointList,
-  checkpointLoad,
-  checkpointSave
-};
-//# sourceMappingURL=checkpoint.js.map
+import{existsSync as s,mkdirSync as d,readdirSync as f,readFileSync as a,writeFileSync as u}from"node:fs";import{resolve as i}from"node:path";const g=".kb-state/checkpoints";function o(n){const e=n??process.cwd(),t=i(e,g);return s(t)||d(t,{recursive:!0}),t}function C(n,e,t){const r=n.toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-|-$/g,"")||"checkpoint",c={id:`${Date.now()}-${r}`,label:n,createdAt:new Date().toISOString(),data:e,files:t?.files,notes:t?.notes},p=i(o(t?.cwd),`${c.id}.json`);return u(p,`${JSON.stringify(c,null,2)}
+`,"utf-8"),c}function S(n,e){const t=i(o(e),`${n}.json`);if(s(t))return JSON.parse(a(t,"utf-8"))}function k(n){const e=o(n);return f(e).filter(t=>t.endsWith(".json")).map(t=>JSON.parse(a(i(e,t),"utf-8"))).sort((t,r)=>r.createdAt.localeCompare(t.createdAt))}function w(n){return k(n)[0]}export{w as checkpointLatest,k as checkpointList,S as checkpointLoad,C as checkpointSave};

package/packages/tools/dist/codemod.js

@@ -1,69 +1,2 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { relative } from "node:path";
-import { DEFAULT_TOOL_EXTENSIONS, matchesGlobPattern, walkFiles } from "./file-walk.js";
-function normalizePath(path) {
-  return path.replace(/\\/g, "/");
-}
-async function codemod(options) {
-  const {
-    rootPath,
-    rules,
-    extensions = DEFAULT_TOOL_EXTENSIONS,
-    exclude = [],
-    dryRun = false
-  } = options;
-  const compiledRules = rules.map((rule) => ({
-    ...rule,
-    regex: new RegExp(rule.pattern, "g")
-  }));
-  const filePaths = await walkFiles(rootPath, extensions, exclude);
-  const changes = [];
-  const appliedRules = /* @__PURE__ */ new Set();
-  let filesModified = 0;
-  for (const filePath of filePaths) {
-    const relativePath = normalizePath(relative(rootPath, filePath));
-    const originalContent = await readFile(filePath, "utf-8");
-    const lines = originalContent.split(/\r?\n/);
-    let fileChanged = false;
-    for (const [ruleIndex, rule] of compiledRules.entries()) {
-      if (rule.fileFilter && !matchesGlobPattern(relativePath, rule.fileFilter)) {
-        continue;
-      }
-      for (let index = 0; index < lines.length; index++) {
-        const before = lines[index];
-        rule.regex.lastIndex = 0;
-        const after = before.replace(rule.regex, rule.replacement);
-        if (before === after) {
-          continue;
-        }
-        lines[index] = after;
-        fileChanged = true;
-        appliedRules.add(ruleIndex);
-        changes.push({
-          rule: rule.description,
-          path: relativePath,
-          line: index + 1,
-          before,
-          after
-        });
-      }
-    }
-    if (!fileChanged) {
-      continue;
-    }
-    filesModified += 1;
-    if (!dryRun) {
-      await writeFile(filePath, lines.join("\n"), "utf-8");
-    }
-  }
-  return {
-    changes,
-    rulesApplied: appliedRules.size,
-    filesModified,
-    dryRun
-  };
-}
-export {
-  codemod
-};
-//# sourceMappingURL=codemod.js.map
+import{readFile as b,writeFile as P}from"node:fs/promises";import{relative as w}from"node:path";import{DEFAULT_TOOL_EXTENSIONS as F,matchesGlobPattern as O,walkFiles as y}from"./file-walk.js";function E(o){return o.replace(/\\/g,"/")}async function v(o){const{rootPath:l,rules:g,extensions:m=F,exclude:h=[],dryRun:a=!1}=o,x=g.map(e=>({...e,regex:new RegExp(e.pattern,"g")})),C=await y(l,m,h),d=[],f=new Set;let c=0;for(const e of C){const u=E(w(l,e)),r=(await b(e,"utf-8")).split(/\r?\n/);let p=!1;for(const[R,t]of x.entries())if(!(t.fileFilter&&!O(u,t.fileFilter)))for(let n=0;n<r.length;n++){const i=r[n];t.regex.lastIndex=0;const s=i.replace(t.regex,t.replacement);i!==s&&(r[n]=s,p=!0,f.add(R),d.push({rule:t.description,path:u,line:n+1,before:i,after:s}))}p&&(c+=1,a||await P(e,r.join(`
+`),"utf-8"))}return{changes:d,rulesApplied:f.size,filesModified:c,dryRun:a}}export{v as codemod};

package/packages/tools/dist/compact.js

@@ -1,60 +1,3 @@
-import { cosineSimilarity, segment } from "./text-utils.js";
-async function compact(embedder, options) {
-  const { text, query, maxChars = 3e3, minScore = 0.3, segmentation = "paragraph" } = options;
-  if (text.length <= maxChars) {
-    return {
-      text,
-      originalChars: text.length,
-      compressedChars: text.length,
-      ratio: 1,
-      segmentsKept: 1,
-      segmentsTotal: 1
-    };
-  }
-  const segments = segment(text, segmentation);
-  if (segments.length === 0) {
-    return {
-      text: "",
-      originalChars: text.length,
-      compressedChars: 0,
-      ratio: 0,
-      segmentsKept: 0,
-      segmentsTotal: 0
-    };
-  }
-  const queryVector = await embedder.embed(query);
-  const scored = [];
-  for (let i = 0; i < segments.length; i++) {
-    const segVector = await embedder.embed(segments[i]);
-    const score = cosineSimilarity(queryVector, segVector);
-    scored.push({ text: segments[i], score, index: i });
-  }
-  const sorted = scored.filter((s) => s.score >= minScore).sort((a, b) => b.score - a.score);
-  const selected = [];
-  let totalChars = 0;
-  for (const seg of sorted) {
-    if (totalChars + seg.text.length > maxChars) {
-      if (totalChars === 0) {
-        selected.push({ ...seg, text: seg.text.slice(0, maxChars) });
-        totalChars = maxChars;
-      }
-      break;
-    }
-    selected.push(seg);
-    totalChars += seg.text.length + 2;
-  }
-  selected.sort((a, b) => a.index - b.index);
-  const compressedText = selected.map((s) => s.text).join("\n\n");
-  return {
-    text: compressedText,
-    originalChars: text.length,
-    compressedChars: compressedText.length,
-    ratio: compressedText.length / text.length,
-    segmentsKept: selected.length,
-    segmentsTotal: segments.length
-  };
-}
-export {
-  compact
-};
-//# sourceMappingURL=compact.js.map
+import{cosineSimilarity as C,segment as b}from"./text-utils.js";async function S(m,g){const{text:t,query:l,maxChars:o=3e3,minScore:h=.3,segmentation:p="paragraph"}=g;if(t.length<=o)return{text:t,originalChars:t.length,compressedChars:t.length,ratio:1,segmentsKept:1,segmentsTotal:1};const n=b(t,p);if(n.length===0)return{text:"",originalChars:t.length,compressedChars:0,ratio:0,segmentsKept:0,segmentsTotal:0};const d=await m.embed(l),c=[];for(let e=0;e<n.length;e++){const s=await m.embed(n[e]),u=C(d,s);c.push({text:n[e],score:u,index:e})}const x=c.filter(e=>e.score>=h).sort((e,s)=>s.score-e.score),r=[];let i=0;for(const e of x){if(i+e.text.length>o){i===0&&(r.push({...e,text:e.text.slice(0,o)}),i=o);break}r.push(e),i+=e.text.length+2}r.sort((e,s)=>e.index-s.index);const a=r.map(e=>e.text).join(`
+
+`);return{text:a,originalChars:t.length,compressedChars:a.length,ratio:a.length/t.length,segmentsKept:r.length,segmentsTotal:n.length}}export{S as compact};

package/packages/tools/dist/data-transform.js

@@ -1,124 +1 @@
-function dataTransform(options) {
-  const { input, expression } = options;
-  const data = typeof input === "string" ? JSON.parse(input) : input;
-  let output;
-  if (expression === ".") {
-    output = data;
-  } else if (expression === "keys") {
-    output = Object.keys(asRecord(data));
-  } else if (expression === "values") {
-    output = Object.values(asRecord(data));
-  } else if (expression === "length") {
-    output = Array.isArray(data) ? data.length : Object.keys(asRecord(data)).length;
-  } else if (expression === "flatten") {
-    output = asArray(data).flat();
-  } else if (expression === "unique") {
-    output = [...new Set(asArray(data))];
-  } else if (expression === "sort") {
-    output = [...asArray(data)].sort();
-  } else if (expression === "reverse") {
-    output = [...asArray(data)].reverse();
-  } else if (expression.startsWith(".")) {
-    output = resolvePath(data, expression.slice(1));
-  } else if (expression.startsWith("map(") && expression.endsWith(")")) {
-    const field = expression.slice(4, -1).trim();
-    const path = field.startsWith(".") ? field.slice(1) : field;
-    output = asArray(data).map((item) => resolvePath(item, path));
-  } else if (expression.startsWith("select(") && expression.endsWith(")")) {
-    output = filterByCondition(asArray(data), expression.slice(7, -1).trim());
-  } else if (expression.startsWith("group_by(") && expression.endsWith(")")) {
-    const field = expression.slice(9, -1).trim().replace(/^\./, "");
-    const groups = {};
-    for (const item of asArray(data)) {
-      const key = String(resolvePath(item, field) ?? "null");
-      if (!groups[key]) {
-        groups[key] = [];
-      }
-      groups[key].push(item);
-    }
-    output = groups;
-  } else if (expression.startsWith("pick(") && expression.endsWith(")")) {
-    const fields = expression.slice(5, -1).split(",").map((field) => field.trim().replace(/^\./, "")).filter(Boolean);
-    output = Array.isArray(data) ? asArray(data).map((item) => pickFields(item, fields)) : pickFields(data, fields);
-  } else {
-    throw new Error(
-      `Unsupported expression: ${expression}. Supported: ., .path.to.field, keys, values, length, flatten, unique, sort, reverse, map(.field), select(.field == | != | > | < | >= | <= "value"), group_by(.field), pick(.a, .b)`
-    );
-  }
-  return {
-    output,
-    outputString: typeof output === "string" ? output : JSON.stringify(output, null, 2) ?? "null"
-  };
-}
-function filterByCondition(items, condition) {
-  const match = condition.match(/^\.?([\w.[\]]+)\s*(==|!=|>=|<=|>|<)\s*"?([^"]*)"?$/);
-  if (!match) {
-    throw new Error(`Unsupported select expression: ${condition}`);
-  }
-  const [, field, operator, value] = match;
-  return items.filter((item) => {
-    const resolved = resolvePath(item, field);
-    const resolvedStr = String(resolved);
-    switch (operator) {
-      case "==":
-        return resolvedStr === value;
-      case "!=":
-        return resolvedStr !== value;
-      case ">":
-      case "<":
-      case ">=":
-      case "<=": {
-        const numResolved = Number(resolved);
-        const numValue = Number(value);
-        if (Number.isNaN(numResolved) || Number.isNaN(numValue)) return false;
-        if (operator === ">") return numResolved > numValue;
-        if (operator === "<") return numResolved < numValue;
-        if (operator === ">=") return numResolved >= numValue;
-        return numResolved <= numValue;
-      }
-      default:
-        return false;
-    }
-  });
-}
-function pickFields(input, fields) {
-  const picked = {};
-  for (const field of fields) {
-    picked[field] = resolvePath(input, field);
-  }
-  return picked;
-}
-function resolvePath(input, path) {
-  if (!path) return input;
-  const tokens = [...path.matchAll(/([^.[\]]+)|\[(\d+)\]/g)].map(
-    (match) => match[1] ?? Number.parseInt(match[2], 10)
-  );
-  let current = input;
-  for (const token of tokens) {
-    if (current == null) return void 0;
-    if (typeof token === "number") {
-      if (!Array.isArray(current)) return void 0;
-      current = current[token];
-      continue;
-    }
-    if (typeof current !== "object") return void 0;
-    current = current[token];
-  }
-  return current;
-}
-function asArray(value) {
-  if (!Array.isArray(value)) {
-    throw new Error("Operation requires an array input.");
-  }
-  return value;
-}
-function asRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Operation requires an object input.");
-  }
-  return value;
-}
-export {
-  dataTransform
-};
-//# sourceMappingURL=data-transform.js.map
+function g(t){const{input:o,expression:e}=t,n=typeof o=="string"?JSON.parse(o):o;let r;if(e===".")r=n;else if(e==="keys")r=Object.keys(d(n));else if(e==="values")r=Object.values(d(n));else if(e==="length")r=Array.isArray(n)?n.length:Object.keys(d(n)).length;else if(e==="flatten")r=u(n).flat();else if(e==="unique")r=[...new Set(u(n))];else if(e==="sort")r=[...u(n)].sort();else if(e==="reverse")r=[...u(n)].reverse();else if(e.startsWith("."))r=p(n,e.slice(1));else if(e.startsWith("map(")&&e.endsWith(")")){const s=e.slice(4,-1).trim(),i=s.startsWith(".")?s.slice(1):s;r=u(n).map(a=>p(a,i))}else if(e.startsWith("select(")&&e.endsWith(")"))r=w(u(n),e.slice(7,-1).trim());else if(e.startsWith("group_by(")&&e.endsWith(")")){const s=e.slice(9,-1).trim().replace(/^\./,""),i={};for(const a of u(n)){const f=String(p(a,s)??"null");i[f]||(i[f]=[]),i[f].push(a)}r=i}else if(e.startsWith("pick(")&&e.endsWith(")")){const s=e.slice(5,-1).split(",").map(i=>i.trim().replace(/^\./,"")).filter(Boolean);r=Array.isArray(n)?u(n).map(i=>k(i,s)):k(n,s)}else throw new Error(`Unsupported expression: ${e}. Supported: ., .path.to.field, keys, values, length, flatten, unique, sort, reverse, map(.field), select(.field == | != | > | < | >= | <= "value"), group_by(.field), pick(.a, .b)`);return{output:r,outputString:typeof r=="string"?r:JSON.stringify(r,null,2)??"null"}}function w(t,o){const e=o.match(/^\.?([\w.[\]]+)\s*(==|!=|>=|<=|>|<)\s*"?([^"]*)"?$/);if(!e)throw new Error(`Unsupported select expression: ${o}`);const[,n,r,s]=e;return t.filter(i=>{const a=p(i,n),f=String(a);switch(r){case"==":return f===s;case"!=":return f!==s;case">":case"<":case">=":case"<=":{const l=Number(a),c=Number(s);return Number.isNaN(l)||Number.isNaN(c)?!1:r===">"?l>c:r==="<"?l<c:r===">="?l>=c:l<=c}default:return!1}})}function k(t,o){const e={};for(const n of o)e[n]=p(t,n);return e}function p(t,o){if(!o)return t;const e=[...o.matchAll(/([^.[\]]+)|\[(\d+)\]/g)].map(r=>r[1]??Number.parseInt(r[2],10));let n=t;for(const r of e){if(n==null)return;if(typeof r=="number"){if(!Array.isArray(n))return;n=n[r];continue}if(typeof n!="object")return;n=n[r]}return n}function u(t){if(!Array.isArray(t))throw new Error("Operation requires an array input.");return t}function d(t){if(!t||typeof t!="object"||Array.isArray(t))throw new Error("Operation requires an object input.");return t}export{g as dataTransform};

package/packages/tools/dist/dead-symbols.js

@@ -1,71 +1,2 @@
-async function findDeadSymbols(embedder, store, options = {}) {
-  const { rootPath, limit = 100 } = options;
-  const exportVector = await embedder.embed("export function class const type interface enum");
-  const exportChunks = await store.search(exportVector, { limit: limit * 3 });
-  const exportPattern = /^export\s+(?:async\s+)?(?:function|class|const|let|interface|type|enum)\s+(\w+)/gm;
-  const exports = [];
-  for (const chunk of exportChunks) {
-    if (!matchesRootPath(chunk.record.sourcePath, rootPath)) continue;
-    const content = chunk.record.content;
-    exportPattern.lastIndex = 0;
-    for (const match of content.matchAll(exportPattern)) {
-      const matchIndex = match.index ?? 0;
-      const linesBefore = content.slice(0, matchIndex).split("\n").length - 1;
-      const kindMatch = content.slice(matchIndex).match(/export\s+(?:async\s+)?(\w+)/);
-      exports.push({
-        name: match[1],
-        path: chunk.record.sourcePath,
-        line: chunk.record.startLine + linesBefore,
-        kind: kindMatch?.[1] ?? "unknown"
-      });
-    }
-  }
-  const uniqueExports = /* @__PURE__ */ new Map();
-  for (const exportedSymbol of exports) {
-    const key = `${exportedSymbol.path}:${exportedSymbol.name}`;
-    if (!uniqueExports.has(key)) uniqueExports.set(key, exportedSymbol);
-  }
-  const deadSymbols = [];
-  for (const exportedSymbol of uniqueExports.values()) {
-    const escapedName = escapeRegExp(exportedSymbol.name);
-    const importPattern = new RegExp(`import\\s+.*\\b${escapedName}\\b.*from`, "m");
-    const reexportPattern = new RegExp(`export\\s+\\{[^}]*\\b${escapedName}\\b`, "m");
-    const importResults = await store.ftsSearch(`import ${exportedSymbol.name}`, { limit: 10 });
-    const isImported = importResults.some(
-      (result) => result.record.sourcePath !== exportedSymbol.path && importPattern.test(result.record.content)
-    );
-    const isReexported = importResults.some(
-      (result) => result.record.sourcePath !== exportedSymbol.path && reexportPattern.test(result.record.content)
-    );
-    if (!isImported && !isReexported) {
-      deadSymbols.push(exportedSymbol);
-    }
-  }
-  deadSymbols.sort(
-    (left, right) => left.path === right.path ? left.line - right.line : left.path.localeCompare(right.path)
-  );
-  return {
-    deadSymbols,
-    totalExports: uniqueExports.size,
-    totalDead: deadSymbols.length
-  };
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function matchesRootPath(sourcePath, rootPath) {
-  if (!rootPath) return true;
-  const normalizedRoot = normalizePath(rootPath).replace(/\/+$/, "");
-  if (/^[A-Za-z]:\//.test(normalizedRoot) || normalizedRoot.startsWith("/")) {
-    return true;
-  }
-  const normalizedSource = normalizePath(sourcePath);
-  return normalizedSource === normalizedRoot || normalizedSource.startsWith(`${normalizedRoot}/`);
-}
-function normalizePath(value) {
-  return value.replace(/\\/g, "/").replace(/^\.\//, "");
-}
-export {
-  findDeadSymbols
-};
-//# sourceMappingURL=dead-symbols.js.map
+async function w(o,r,n={}){const{rootPath:a,limit:b=100}=n,x=await o.embed("export function class const type interface enum"),y=await r.search(x,{limit:b*3}),u=/^export\s+(?:async\s+)?(?:function|class|const|let|interface|type|enum)\s+(\w+)/gm,h=[];for(const t of y){if(!D(t.record.sourcePath,a))continue;const e=t.record.content;u.lastIndex=0;for(const m of e.matchAll(u)){const p=m.index??0,d=e.slice(0,p).split(`
+`).length-1,l=e.slice(p).match(/export\s+(?:async\s+)?(\w+)/);h.push({name:m[1],path:t.record.sourcePath,line:t.record.startLine+d,kind:l?.[1]??"unknown"})}}const c=new Map;for(const t of h){const e=`${t.path}:${t.name}`;c.has(e)||c.set(e,t)}const i=[];for(const t of c.values()){const e=S(t.name),m=new RegExp(`import\\s+.*\\b${e}\\b.*from`,"m"),p=new RegExp(`export\\s+\\{[^}]*\\b${e}\\b`,"m"),d=await r.ftsSearch(`import ${t.name}`,{limit:10}),l=d.some(s=>s.record.sourcePath!==t.path&&m.test(s.record.content)),g=d.some(s=>s.record.sourcePath!==t.path&&p.test(s.record.content));!l&&!g&&i.push(t)}return i.sort((t,e)=>t.path===e.path?t.line-e.line:t.path.localeCompare(e.path)),{deadSymbols:i,totalExports:c.size,totalDead:i.length}}function S(o){return o.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function D(o,r){if(!r)return!0;const n=f(r).replace(/\/+$/,"");if(/^[A-Za-z]:\//.test(n)||n.startsWith("/"))return!0;const a=f(o);return a===n||a.startsWith(`${n}/`)}function f(o){return o.replace(/\\/g,"/").replace(/^\.\//,"")}export{w as findDeadSymbols};