@vpxa/kb 0.1.1 → 0.1.3

package/packages/tools/dist/schema-validate.js

@@ -1,141 +1 @@
-function schemaValidate(options) {
-  const errors = [];
-  validateNode(options.data, options.schema, "$", errors);
-  return { valid: errors.length === 0, errors };
-}
-function validateNode(data, schema, path, errors) {
-  if ("type" in schema) {
-    const expected = schema.type;
-    if (!checkType(data, expected)) {
-      errors.push({
-        path,
-        message: `Expected type "${expected}"`,
-        expected,
-        received: getType(data)
-      });
-      return;
-    }
-  }
-  if ("enum" in schema) {
-    const allowed = schema.enum;
-    if (!allowed.some((v) => JSON.stringify(v) === JSON.stringify(data))) {
-      errors.push({
-        path,
-        message: `Must be one of: ${JSON.stringify(allowed)}`,
-        received: JSON.stringify(data)
-      });
-    }
-  }
-  if ("const" in schema) {
-    if (JSON.stringify(data) !== JSON.stringify(schema.const)) {
-      errors.push({
-        path,
-        message: `Must equal ${JSON.stringify(schema.const)}`,
-        received: JSON.stringify(data)
-      });
-    }
-  }
-  if (typeof data === "string") {
-    if ("minLength" in schema && data.length < schema.minLength) {
-      errors.push({
-        path,
-        message: `String too short (min: ${schema.minLength})`,
-        received: `length ${data.length}`
-      });
-    }
-    if ("maxLength" in schema && data.length > schema.maxLength) {
-      errors.push({
-        path,
-        message: `String too long (max: ${schema.maxLength})`,
-        received: `length ${data.length}`
-      });
-    }
-    if ("pattern" in schema && !new RegExp(schema.pattern).test(data)) {
-      errors.push({ path, message: `Does not match pattern: ${schema.pattern}` });
-    }
-  }
-  if (typeof data === "number") {
-    if ("minimum" in schema && data < schema.minimum) {
-      errors.push({ path, message: `Below minimum (${schema.minimum})`, received: String(data) });
-    }
-    if ("maximum" in schema && data > schema.maximum) {
-      errors.push({ path, message: `Above maximum (${schema.maximum})`, received: String(data) });
-    }
-  }
-  if (Array.isArray(data)) {
-    if ("minItems" in schema && data.length < schema.minItems) {
-      errors.push({
-        path,
-        message: `Too few items (min: ${schema.minItems})`,
-        received: `length ${data.length}`
-      });
-    }
-    if ("maxItems" in schema && data.length > schema.maxItems) {
-      errors.push({
-        path,
-        message: `Too many items (max: ${schema.maxItems})`,
-        received: `length ${data.length}`
-      });
-    }
-    if ("items" in schema) {
-      for (let i = 0; i < data.length; i++) {
-        validateNode(data[i], schema.items, `${path}[${i}]`, errors);
-      }
-    }
-  }
-  if (data && typeof data === "object" && !Array.isArray(data)) {
-    const obj = data;
-    if ("required" in schema) {
-      for (const key of schema.required) {
-        if (!(key in obj)) {
-          errors.push({ path: `${path}.${key}`, message: "Required property missing" });
-        }
-      }
-    }
-    if ("properties" in schema) {
-      const props = schema.properties;
-      for (const [key, propSchema] of Object.entries(props)) {
-        if (key in obj) {
-          validateNode(obj[key], propSchema, `${path}.${key}`, errors);
-        }
-      }
-    }
-    if ("additionalProperties" in schema && schema.additionalProperties === false) {
-      const defined = Object.keys(schema.properties ?? {});
-      for (const key of Object.keys(obj)) {
-        if (!defined.includes(key)) {
-          errors.push({ path: `${path}.${key}`, message: "Additional property not allowed" });
-        }
-      }
-    }
-  }
-}
-function checkType(data, type) {
-  switch (type) {
-    case "string":
-      return typeof data === "string";
-    case "number":
-      return typeof data === "number" && !Number.isNaN(data);
-    case "integer":
-      return typeof data === "number" && Number.isInteger(data);
-    case "boolean":
-      return typeof data === "boolean";
-    case "null":
-      return data === null;
-    case "array":
-      return Array.isArray(data);
-    case "object":
-      return data !== null && typeof data === "object" && !Array.isArray(data);
-    default:
-      return true;
-  }
-}
-function getType(data) {
-  if (data === null) return "null";
-  if (Array.isArray(data)) return "array";
-  return typeof data;
-}
-export {
-  schemaValidate
-};
-//# sourceMappingURL=schema-validate.js.map
+function m(e){const n=[];return u(e.data,e.schema,"$",n),{valid:n.length===0,errors:n}}function u(e,n,r,t){if("type"in n){const i=n.type;if(!f(e,i)){t.push({path:r,message:`Expected type "${i}"`,expected:i,received:l(e)});return}}if("enum"in n){const i=n.enum;i.some(o=>JSON.stringify(o)===JSON.stringify(e))||t.push({path:r,message:`Must be one of: ${JSON.stringify(i)}`,received:JSON.stringify(e)})}if("const"in n&&JSON.stringify(e)!==JSON.stringify(n.const)&&t.push({path:r,message:`Must equal ${JSON.stringify(n.const)}`,received:JSON.stringify(e)}),typeof e=="string"&&("minLength"in n&&e.length<n.minLength&&t.push({path:r,message:`String too short (min: ${n.minLength})`,received:`length ${e.length}`}),"maxLength"in n&&e.length>n.maxLength&&t.push({path:r,message:`String too long (max: ${n.maxLength})`,received:`length ${e.length}`}),"pattern"in n&&!new RegExp(n.pattern).test(e)&&t.push({path:r,message:`Does not match pattern: ${n.pattern}`})),typeof e=="number"&&("minimum"in n&&e<n.minimum&&t.push({path:r,message:`Below minimum (${n.minimum})`,received:String(e)}),"maximum"in n&&e>n.maximum&&t.push({path:r,message:`Above maximum (${n.maximum})`,received:String(e)})),Array.isArray(e)&&("minItems"in n&&e.length<n.minItems&&t.push({path:r,message:`Too few items (min: ${n.minItems})`,received:`length ${e.length}`}),"maxItems"in n&&e.length>n.maxItems&&t.push({path:r,message:`Too many items (max: ${n.maxItems})`,received:`length ${e.length}`}),"items"in n))for(let i=0;i<e.length;i++)u(e[i],n.items,`${r}[${i}]`,t);if(e&&typeof e=="object"&&!Array.isArray(e)){const i=e;if("required"in n)for(const o of n.required)o in i||t.push({path:`${r}.${o}`,message:"Required property missing"});if("properties"in n){const o=n.properties;for(const[s,g]of Object.entries(o))s in i&&u(i[s],g,`${r}.${s}`,t)}if("additionalProperties"in n&&n.additionalProperties===!1){const o=Object.keys(n.properties??{});for(const s of Object.keys(i))o.includes(s)||t.push({path:`${r}.${s}`,message:"Additional property not allowed"})}}}function f(e,n){switch(n){case"string":return typeof e=="string";case"number":return typeof e=="number"&&!Number.isNaN(e);case"integer":return typeof e=="number"&&Number.isInteger(e);case"boolean":return typeof e=="boolean";case"null":return e===null;case"array":return Array.isArray(e);case"object":return e!==null&&typeof e=="object"&&!Array.isArray(e);default:return!0}}function l(e){return e===null?"null":Array.isArray(e)?"array":typeof e}export{m as schemaValidate};

package/packages/tools/dist/scope-map.js

@@ -1,72 +1 @@
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-async function scopeMap(embedder, store, options) {
-  const { task, maxFiles = 15, contentType, origin } = options;
-  const queryVector = await embedder.embed(task);
-  const searchOpts = {
-    limit: maxFiles * 3,
-    // Over-fetch to group by file
-    contentType,
-    origin
-  };
-  const results = await store.search(queryVector, searchOpts);
-  const fileMap = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    const path = result.record.sourcePath;
-    const existing = fileMap.get(path);
-    if (existing) {
-      existing.chunks.push(result);
-      existing.totalChars += result.record.content.length;
-      existing.maxScore = Math.max(existing.maxScore, result.score);
-    } else {
-      fileMap.set(path, {
-        chunks: [result],
-        totalChars: result.record.content.length,
-        maxScore: result.score
-      });
-    }
-  }
-  const entries = [...fileMap.entries()].sort(([, a], [, b]) => b.maxScore - a.maxScore).slice(0, maxFiles).map(([path, { chunks, maxScore }]) => {
-    const focusRanges = chunks.sort((a, b) => a.record.startLine - b.record.startLine).map((c) => ({
-      start: c.record.startLine,
-      end: c.record.endLine,
-      heading: c.record.headingPath
-    }));
-    const topChunk = chunks.sort((a, b) => b.score - a.score)[0];
-    const reason = topChunk.record.headingPath ? `Matches: ${topChunk.record.headingPath}` : `Contains relevant ${topChunk.record.contentType} content`;
-    return {
-      path,
-      reason,
-      estimatedTokens: 0,
-      // computed below from actual content
-      relevance: maxScore,
-      focusRanges
-    };
-  });
-  for (const entry of entries) {
-    const fileChunks = fileMap.get(entry.path);
-    if (fileChunks) {
-      entry.estimatedTokens = estimateTokens(
-        fileChunks.chunks.map((c) => c.record.content).join("")
-      );
-    }
-  }
-  const totalEstimatedTokens = entries.reduce((sum, e) => sum + e.estimatedTokens, 0);
-  const readingOrder = [...entries].sort((a, b) => {
-    const aIsConfig = a.path.includes("config") || a.path.includes("types") ? -1 : 0;
-    const bIsConfig = b.path.includes("config") || b.path.includes("types") ? -1 : 0;
-    if (aIsConfig !== bIsConfig) return aIsConfig - bIsConfig;
-    return b.relevance - a.relevance;
-  }).map((e) => e.path);
-  return {
-    task,
-    files: entries,
-    totalEstimatedTokens,
-    readingOrder
-  };
-}
-export {
-  scopeMap
-};
-//# sourceMappingURL=scope-map.js.map
+function M(c){return Math.ceil(c.length/4)}async function T(c,h,u){const{task:d,maxFiles:m=15,contentType:l,origin:g}=u,f=await c.embed(d),S={limit:m*3,contentType:l,origin:g},x=await h.search(f,S),s=new Map;for(const e of x){const t=e.record.sourcePath,r=s.get(t);r?(r.chunks.push(e),r.totalChars+=e.record.content.length,r.maxScore=Math.max(r.maxScore,e.score)):s.set(t,{chunks:[e],totalChars:e.record.content.length,maxScore:e.score})}const o=[...s.entries()].sort(([,e],[,t])=>t.maxScore-e.maxScore).slice(0,m).map(([e,{chunks:t,maxScore:r}])=>{const a=t.sort((n,p)=>n.record.startLine-p.record.startLine).map(n=>({start:n.record.startLine,end:n.record.endLine,heading:n.record.headingPath})),i=t.sort((n,p)=>p.score-n.score)[0],b=i.record.headingPath?`Matches: ${i.record.headingPath}`:`Contains relevant ${i.record.contentType} content`;return{path:e,reason:b,estimatedTokens:0,relevance:r,focusRanges:a}});for(const e of o){const t=s.get(e.path);t&&(e.estimatedTokens=M(t.chunks.map(r=>r.record.content).join("")))}const y=o.reduce((e,t)=>e+t.estimatedTokens,0),k=[...o].sort((e,t)=>{const r=e.path.includes("config")||e.path.includes("types")?-1:0,a=t.path.includes("config")||t.path.includes("types")?-1:0;return r!==a?r-a:t.relevance-e.relevance}).map(e=>e.path);return{task:d,files:o,totalEstimatedTokens:y,readingOrder:k}}export{T as scopeMap};

package/packages/tools/dist/snippet.js

@@ -1,80 +1 @@
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync
-} from "node:fs";
-import { join } from "node:path";
-const SNIPPETS_DIR = () => join(process.cwd(), ".kb-state", "snippets");
-function ensureDir() {
-  const dir = SNIPPETS_DIR();
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  return dir;
-}
-function safeName(name) {
-  const safe = name.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safe) throw new Error("Invalid snippet name");
-  return safe;
-}
-function snippet(options) {
-  switch (options.action) {
-    case "save": {
-      if (!options.name || !options.code) throw new Error("name and code required for save");
-      const dir = ensureDir();
-      const name = safeName(options.name);
-      const filePath = join(dir, `${name}.json`);
-      const existing = existsSync(filePath) ? JSON.parse(readFileSync(filePath, "utf8")) : null;
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const entry = {
-        name: options.name,
-        language: options.language ?? "text",
-        code: options.code,
-        tags: options.tags ?? [],
-        created: existing?.created ?? now,
-        updated: now
-      };
-      writeFileSync(filePath, JSON.stringify(entry, null, 2));
-      return entry;
-    }
-    case "get": {
-      if (!options.name) throw new Error("name required for get");
-      const filePath = join(SNIPPETS_DIR(), `${safeName(options.name)}.json`);
-      if (!existsSync(filePath)) throw new Error(`Snippet not found: ${options.name}`);
-      return JSON.parse(readFileSync(filePath, "utf8"));
-    }
-    case "list": {
-      const dir = ensureDir();
-      const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-      const snippets = files.map((f) => {
-        const data = JSON.parse(readFileSync(join(dir, f), "utf8"));
-        return { name: data.name, language: data.language, tags: data.tags, updated: data.updated };
-      });
-      return { snippets };
-    }
-    case "search": {
-      if (!options.query) throw new Error("query required for search");
-      const q = options.query.toLowerCase();
-      const dir = ensureDir();
-      const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-      const snippets = files.map((f) => JSON.parse(readFileSync(join(dir, f), "utf8"))).filter(
-        (s) => s.name.toLowerCase().includes(q) || s.tags.some((t) => t.toLowerCase().includes(q)) || s.language.toLowerCase().includes(q) || s.code.toLowerCase().includes(q)
-      ).map((s) => ({ name: s.name, language: s.language, tags: s.tags, updated: s.updated }));
-      return { snippets };
-    }
-    case "delete": {
-      if (!options.name) throw new Error("name required for delete");
-      const filePath = join(SNIPPETS_DIR(), `${safeName(options.name)}.json`);
-      if (!existsSync(filePath)) return { deleted: false };
-      unlinkSync(filePath);
-      return { deleted: true };
-    }
-    default:
-      throw new Error(`Unknown action: ${options.action}`);
-  }
-}
-export {
-  snippet
-};
-//# sourceMappingURL=snippet.js.map
+import{existsSync as p,mkdirSync as f,readdirSync as l,readFileSync as u,unlinkSync as m,writeFileSync as S}from"node:fs";import{join as a}from"node:path";const o=()=>a(process.cwd(),".kb-state","snippets");function d(){const e=o();return p(e)||f(e,{recursive:!0}),e}function g(e){const n=e.replace(/[^a-zA-Z0-9_-]/g,"_");if(!n)throw new Error("Invalid snippet name");return n}function h(e){switch(e.action){case"save":{if(!e.name||!e.code)throw new Error("name and code required for save");const n=d(),s=g(e.name),i=a(n,`${s}.json`),r=p(i)?JSON.parse(u(i,"utf8")):null,t=new Date().toISOString(),c={name:e.name,language:e.language??"text",code:e.code,tags:e.tags??[],created:r?.created??t,updated:t};return S(i,JSON.stringify(c,null,2)),c}case"get":{if(!e.name)throw new Error("name required for get");const n=a(o(),`${g(e.name)}.json`);if(!p(n))throw new Error(`Snippet not found: ${e.name}`);return JSON.parse(u(n,"utf8"))}case"list":{const n=d();return{snippets:l(n).filter(r=>r.endsWith(".json")).map(r=>{const t=JSON.parse(u(a(n,r),"utf8"));return{name:t.name,language:t.language,tags:t.tags,updated:t.updated}})}}case"search":{if(!e.query)throw new Error("query required for search");const n=e.query.toLowerCase(),s=d();return{snippets:l(s).filter(t=>t.endsWith(".json")).map(t=>JSON.parse(u(a(s,t),"utf8"))).filter(t=>t.name.toLowerCase().includes(n)||t.tags.some(c=>c.toLowerCase().includes(n))||t.language.toLowerCase().includes(n)||t.code.toLowerCase().includes(n)).map(t=>({name:t.name,language:t.language,tags:t.tags,updated:t.updated}))}}case"delete":{if(!e.name)throw new Error("name required for delete");const n=a(o(),`${g(e.name)}.json`);return p(n)?(m(n),{deleted:!0}):{deleted:!1}}default:throw new Error(`Unknown action: ${e.action}`)}}export{h as snippet};

package/packages/tools/dist/stash.js

@@ -1,60 +1,2 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-const STASH_DIR = ".kb-state";
-const STASH_FILE = "stash.json";
-function stashPath(cwd) {
-  const root = cwd ?? process.cwd();
-  return resolve(root, STASH_DIR, STASH_FILE);
-}
-function loadStash(cwd) {
-  const path = stashPath(cwd);
-  if (!existsSync(path)) return {};
-  const raw = readFileSync(path, "utf-8");
-  return JSON.parse(raw);
-}
-function saveStash(data, cwd) {
-  const path = stashPath(cwd);
-  const dir = dirname(path);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(path, `${JSON.stringify(data, null, 2)}
-`, "utf-8");
-}
-function stashSet(key, value, cwd) {
-  const stash = loadStash(cwd);
-  const entry = {
-    key,
-    value,
-    type: typeof value,
-    storedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  stash[key] = entry;
-  saveStash(stash, cwd);
-  return entry;
-}
-function stashGet(key, cwd) {
-  return loadStash(cwd)[key];
-}
-function stashList(cwd) {
-  return Object.values(loadStash(cwd));
-}
-function stashDelete(key, cwd) {
-  const stash = loadStash(cwd);
-  if (!(key in stash)) return false;
-  delete stash[key];
-  saveStash(stash, cwd);
-  return true;
-}
-function stashClear(cwd) {
-  const stash = loadStash(cwd);
-  const count = Object.keys(stash).length;
-  saveStash({}, cwd);
-  return count;
-}
-export {
-  stashClear,
-  stashDelete,
-  stashGet,
-  stashList,
-  stashSet
-};
-//# sourceMappingURL=stash.js.map
+import{existsSync as a,mkdirSync as u,readFileSync as h,writeFileSync as S}from"node:fs";import{dirname as g,resolve as f}from"node:path";const y=".kb-state",p="stash.json";function c(t){const n=t??process.cwd();return f(n,y,p)}function e(t){const n=c(t);if(!a(n))return{};const r=h(n,"utf-8");return JSON.parse(r)}function o(t,n){const r=c(n),s=g(r);a(s)||u(s,{recursive:!0}),S(r,`${JSON.stringify(t,null,2)}
+`,"utf-8")}function E(t,n,r){const s=e(r),i={key:t,value:n,type:typeof n,storedAt:new Date().toISOString()};return s[t]=i,o(s,r),i}function m(t,n){return e(n)[t]}function x(t){return Object.values(e(t))}function b(t,n){const r=e(n);return t in r?(delete r[t],o(r,n),!0):!1}function v(t){const n=e(t),r=Object.keys(n).length;return o({},t),r}export{v as stashClear,b as stashDelete,m as stashGet,x as stashList,E as stashSet};

package/packages/tools/dist/stratum-card.js

@@ -1,239 +1,6 @@
-import { readFile } from "node:fs/promises";
-import { basename, extname, relative } from "node:path";
-import { fileSummary } from "./file-summary.js";
-import { cosineSimilarity, estimateTokens, segment } from "./text-utils.js";
-const DEFAULT_MAX_CONTENT_CHARS = 800;
-const UNKNOWN_LIMIT = 3;
-async function stratumCard(embedder, options) {
-  const { files, query, tier = "T1", maxContentChars = DEFAULT_MAX_CONTENT_CHARS } = options;
-  const queryVector = tier === "T2" ? await embedder.embedQuery(query) : null;
-  const cards = await Promise.all(
-    files.map(async (filePath) => {
-      try {
-        const content = await readFile(filePath, "utf-8");
-        const originalTokenEstimate = estimateTokens(content);
-        if (content.includes("\0")) {
-          return buildErrorCard(filePath, tier, "binary", "binary file", originalTokenEstimate);
-        }
-        if (content.trim().length === 0) {
-          const card2 = formatCard({
-            displayPath: formatDisplayPath(filePath),
-            tier,
-            role: "empty",
-            deps: [],
-            exports: [],
-            unknowns: [],
-            riskTier: "low"
-          });
-          return {
-            path: filePath,
-            tier,
-            card: card2,
-            unknowns: [],
-            riskTier: "low",
-            tokenEstimate: estimateTokens(card2),
-            originalTokenEstimate
-          };
-        }
-        const summary = await fileSummary({ path: filePath });
-        const role = inferRole(filePath, summary);
-        const unknowns = detectUnknowns(content, summary);
-        const riskTier = classifyRisk(filePath, summary);
-        const deps = getTopDeps(summary);
-        const exports = [...new Set(summary.exports)].slice(0, 5);
-        let card = formatCard({
-          displayPath: formatDisplayPath(filePath),
-          tier,
-          role,
-          deps,
-          exports,
-          unknowns,
-          riskTier
-        });
-        if (tier === "T2" && queryVector) {
-          const context = await compressContent(embedder, queryVector, content, maxContentChars);
-          if (context.length > 0) {
-            card = `${card}
+import{readFile as F}from"node:fs/promises";import{basename as h,extname as I,relative as A}from"node:path";import{fileSummary as j}from"./file-summary.js";import{cosineSimilarity as X,estimateTokens as y,segment as D}from"./text-utils.js";const M=800,S=3;async function B(t,e){const{files:r,query:o,tier:n="T1",maxContentChars:m=M}=e,u=n==="T2"?await t.embedQuery(o):null,l=await Promise.all(r.map(async i=>{try{const c=await F(i,"utf-8"),p=y(c);if(c.includes("\0"))return C(i,n,"binary","binary file",p);if(c.trim().length===0){const g=x({displayPath:T(i),tier:n,role:"empty",deps:[],exports:[],unknowns:[],riskTier:"low"});return{path:i,tier:n,card:g,unknowns:[],riskTier:"low",tokenEstimate:y(g),originalTokenEstimate:p}}const d=await j({path:i}),N=U(i,d),E=W(c,d),w=_(i,d),O=$(d),R=[...new Set(d.exports)].slice(0,5);let f=x({displayPath:T(i),tier:n,role:N,deps:O,exports:R,unknowns:E,riskTier:w});if(n==="T2"&&u){const g=await v(t,u,c,m);g.length>0&&(f=`${f}
 CONTEXT:
-${context}`;
-          }
-        }
-        return {
-          path: filePath,
-          tier,
-          card,
-          unknowns,
-          riskTier,
-          tokenEstimate: estimateTokens(card),
-          originalTokenEstimate
-        };
-      } catch (error) {
-        const message = error.code === "ENOENT" ? "file missing" : "unreadable file";
-        const role = error.code === "ENOENT" ? "missing" : "unreadable";
-        return buildErrorCard(filePath, tier, role, message, 0);
-      }
-    })
-  );
-  const totalTokenEstimate = cards.reduce((total, card) => total + card.tokenEstimate, 0);
-  const totalOriginalTokenEstimate = cards.reduce(
-    (total, card) => total + card.originalTokenEstimate,
-    0
-  );
-  return {
-    cards,
-    totalTokenEstimate,
-    totalOriginalTokenEstimate,
-    compressionRatio: totalOriginalTokenEstimate === 0 ? 0 : totalTokenEstimate / totalOriginalTokenEstimate
-  };
-}
-function buildErrorCard(filePath, tier, role, unknown, originalTokenEstimate) {
-  const card = formatCard({
-    displayPath: formatDisplayPath(filePath),
-    tier,
-    role,
-    deps: [],
-    exports: [],
-    unknowns: [unknown],
-    riskTier: "low"
-  });
-  return {
-    path: filePath,
-    tier,
-    card,
-    unknowns: [unknown],
-    riskTier: "low",
-    tokenEstimate: estimateTokens(card),
-    originalTokenEstimate
-  };
-}
-function formatCard(input) {
-  const { displayPath, tier, role, deps, exports, unknowns, riskTier } = input;
-  return [
-    `[${tier}: ${displayPath}]`,
-    `ROLE: ${role}`,
-    `DEPS: ${joinOrNone(deps)}`,
-    `EXPORTS: ${joinOrNone(exports)}`,
-    `UNKNOWNS: ${joinOrNone(unknowns, "; ")}`,
-    `RISK: ${riskTier}`
-  ].join("\n");
-}
-function formatDisplayPath(filePath) {
-  const relPath = relative(process.cwd(), filePath).replace(/\\/g, "/");
-  if (!relPath || relPath.startsWith("..")) {
-    return basename(filePath);
-  }
-  return relPath;
-}
-function joinOrNone(values, separator = ", ") {
-  return values.length > 0 ? values.join(separator) : "none";
-}
-function inferRole(path, summary) {
-  const name = basename(path);
-  const extension = extname(name).toLowerCase();
-  if ([".json", ".yaml", ".yml", ".env"].includes(extension) || /config|settings/i.test(name)) {
-    return "configuration";
-  }
-  if (/types?\.ts$|\.d\.ts$/i.test(name)) return "type-definitions";
-  if (/schema/i.test(name)) return "schema";
-  if (/test|spec/i.test(name)) return "test";
-  if (/index\.[jt]sx?$/i.test(name)) return "barrel-export";
-  if (/handler|controller|route/i.test(name)) return "entry-point";
-  if (/model|entity/i.test(name)) return "data-model";
-  if (/util|helper/i.test(name)) return "utility";
-  if (/service|provider/i.test(name)) return "service";
-  if (summary.classes.length > 0) return "class-module";
-  if (summary.interfaces.length > 2) return "type-definitions";
-  return "implementation";
-}
-function detectUnknowns(content, summary) {
-  const unknowns = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const match of content.matchAll(/\/\/\s*(TODO|FIXME|HACK|XXX)\s*:?\s*(.+)?$/gm)) {
-    const text = `${match[1]}: ${(match[2] ?? "").trim()}`.trim();
-    addUnknown(unknowns, seen, text.replace(/:\s*$/, ""));
-  }
-  if (hasExportedAny(content)) {
-    addUnknown(unknowns, seen, "exported any usage");
-  }
-  for (const dep of getTopDeps(summary)) {
-    addUnknown(unknowns, seen, `cross-package import: ${dep}`);
-  }
-  return unknowns.slice(0, UNKNOWN_LIMIT);
-}
-function addUnknown(unknowns, seen, value) {
-  if (unknowns.length >= UNKNOWN_LIMIT) return;
-  if (!value || seen.has(value)) return;
-  seen.add(value);
-  unknowns.push(value);
-}
-function hasExportedAny(content) {
-  const patterns = [
-    /export\s+(?:async\s+)?function\s+\w+[^\n{;]*\bany\b/g,
-    /export\s+interface\s+\w+[\s\S]*?\{[\s\S]*?\bany\b[\s\S]*?\}/g,
-    /export\s+type\s+\w+\s*=.*\bany\b/g,
-    /export\s+const\s+\w+[^\n=]*\bany\b/g
-  ];
-  return patterns.some((pattern) => pattern.test(content));
-}
-function classifyRisk(path, summary) {
-  if (/auth|token|permission|secret|credential|encrypt/i.test(path)) return "high";
-  if (/types?\.ts$|schema|contract|\.d\.ts$/i.test(basename(path))) return "medium";
-  if (summary.exports.length > 10) return "medium";
-  return "low";
-}
-function getTopDeps(summary) {
-  return summary.imports.map(extractImportSpecifier).filter((specifier) => Boolean(specifier)).filter((specifier) => !specifier.startsWith("./") && !specifier.startsWith("../")).slice(0, 3);
-}
-function extractImportSpecifier(importLine) {
-  const fromMatch = importLine.match(/from\s+['"]([^'"]+)['"]/);
-  if (fromMatch) {
-    return fromMatch[1];
-  }
-  const sideEffectMatch = importLine.match(/^import\s+['"]([^'"]+)['"]/);
-  return sideEffectMatch ? sideEffectMatch[1] : null;
-}
-async function compressContent(embedder, queryVector, content, maxContentChars) {
-  if (maxContentChars <= 0) {
-    return "";
-  }
-  const segments = segment(content, "paragraph");
-  if (segments.length === 0) {
-    return "";
-  }
-  const scoredSegments = await Promise.all(
-    segments.map(async (text, index) => {
-      const embedding = await embedder.embed(text);
-      return {
-        index,
-        text,
-        score: cosineSimilarity(queryVector, embedding)
-      };
-    })
-  );
-  const selected = [];
-  let usedChars = 0;
-  for (const segmentInfo of scoredSegments.sort((left, right) => right.score - left.score)) {
-    const availableChars = maxContentChars - usedChars;
-    if (availableChars <= 0) {
-      break;
-    }
-    if (segmentInfo.text.length <= availableChars) {
-      selected.push({ index: segmentInfo.index, text: segmentInfo.text });
-      usedChars += segmentInfo.text.length;
-      continue;
-    }
-    if (selected.length === 0) {
-      selected.push({
-        index: segmentInfo.index,
-        text: segmentInfo.text.slice(0, availableChars).trimEnd()
-      });
-      usedChars = maxContentChars;
-    }
-    break;
-  }
-  return selected.sort((left, right) => left.index - right.index).map((entry) => entry.text).filter((entry) => entry.length > 0).join("\n\n");
-}
-export {
-  stratumCard
-};
-//# sourceMappingURL=stratum-card.js.map
+${g}`)}return{path:i,tier:n,card:f,unknowns:E,riskTier:w,tokenEstimate:y(f),originalTokenEstimate:p}}catch(c){const p=c.code==="ENOENT"?"file missing":"unreadable file",d=c.code==="ENOENT"?"missing":"unreadable";return C(i,n,d,p,0)}})),s=l.reduce((i,c)=>i+c.tokenEstimate,0),a=l.reduce((i,c)=>i+c.originalTokenEstimate,0);return{cards:l,totalTokenEstimate:s,totalOriginalTokenEstimate:a,compressionRatio:a===0?0:s/a}}function C(t,e,r,o,n){const m=x({displayPath:T(t),tier:e,role:r,deps:[],exports:[],unknowns:[o],riskTier:"low"});return{path:t,tier:e,card:m,unknowns:[o],riskTier:"low",tokenEstimate:y(m),originalTokenEstimate:n}}function x(t){const{displayPath:e,tier:r,role:o,deps:n,exports:m,unknowns:u,riskTier:l}=t;return[`[${r}: ${e}]`,`ROLE: ${o}`,`DEPS: ${k(n)}`,`EXPORTS: ${k(m)}`,`UNKNOWNS: ${k(u,"; ")}`,`RISK: ${l}`].join(`
+`)}function T(t){const e=A(process.cwd(),t).replace(/\\/g,"/");return!e||e.startsWith("..")?h(t):e}function k(t,e=", "){return t.length>0?t.join(e):"none"}function U(t,e){const r=h(t),o=I(r).toLowerCase();return[".json",".yaml",".yml",".env"].includes(o)||/config|settings/i.test(r)?"configuration":/types?\.ts$|\.d\.ts$/i.test(r)?"type-definitions":/schema/i.test(r)?"schema":/test|spec/i.test(r)?"test":/index\.[jt]sx?$/i.test(r)?"barrel-export":/handler|controller|route/i.test(r)?"entry-point":/model|entity/i.test(r)?"data-model":/util|helper/i.test(r)?"utility":/service|provider/i.test(r)?"service":e.classes.length>0?"class-module":e.interfaces.length>2?"type-definitions":"implementation"}function W(t,e){const r=[],o=new Set;for(const n of t.matchAll(/\/\/\s*(TODO|FIXME|HACK|XXX)\s*:?\s*(.+)?$/gm)){const m=`${n[1]}: ${(n[2]??"").trim()}`.trim();b(r,o,m.replace(/:\s*$/,""))}K(t)&&b(r,o,"exported any usage");for(const n of $(e))b(r,o,`cross-package import: ${n}`);return r.slice(0,S)}function b(t,e,r){t.length>=S||!r||e.has(r)||(e.add(r),t.push(r))}function K(t){return[/export\s+(?:async\s+)?function\s+\w+[^\n{;]*\bany\b/g,/export\s+interface\s+\w+[\s\S]*?\{[\s\S]*?\bany\b[\s\S]*?\}/g,/export\s+type\s+\w+\s*=.*\bany\b/g,/export\s+const\s+\w+[^\n=]*\bany\b/g].some(r=>r.test(t))}function _(t,e){return/auth|token|permission|secret|credential|encrypt/i.test(t)?"high":/types?\.ts$|schema|contract|\.d\.ts$/i.test(h(t))||e.exports.length>10?"medium":"low"}function $(t){return t.imports.map(q).filter(e=>!!e).filter(e=>!e.startsWith("./")&&!e.startsWith("../")).slice(0,3)}function q(t){const e=t.match(/from\s+['"]([^'"]+)['"]/);if(e)return e[1];const r=t.match(/^import\s+['"]([^'"]+)['"]/);return r?r[1]:null}async function v(t,e,r,o){if(o<=0)return"";const n=D(r,"paragraph");if(n.length===0)return"";const m=await Promise.all(n.map(async(s,a)=>{const i=await t.embed(s);return{index:a,text:s,score:X(e,i)}})),u=[];let l=0;for(const s of m.sort((a,i)=>i.score-a.score)){const a=o-l;if(a<=0)break;if(s.text.length<=a){u.push({index:s.index,text:s.text}),l+=s.text.length;continue}u.length===0&&(u.push({index:s.index,text:s.text.slice(0,a).trimEnd()}),l=o);break}return u.sort((s,a)=>s.index-a.index).map(s=>s.text).filter(s=>s.length>0).join(`
+
+`)}export{B as stratumCard};