@vpxa/kb 0.1.1 → 0.1.2

package/packages/server/dist/tools/update.tool.js

@@ -1,42 +1,6 @@
-import { z } from "zod";
-function registerUpdateTool(server, curated) {
-  server.registerTool(
-    "update",
-    {
-      description: "Update an existing curated knowledge entry. Increments version and records the reason in the changelog.",
-      inputSchema: {
-        path: z.string().describe('Relative path within curated/ (e.g., "decisions/use-lancedb.md")'),
-        content: z.string().min(10).describe("New markdown content to replace existing content"),
-        reason: z.string().min(3).describe("Why this update is being made (recorded in changelog)")
-      }
-    },
-    async ({ path, content, reason }) => {
-      try {
-        const result = await curated.update(path, content, reason);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Updated: \`curated/${result.path}\` \u2192 version ${result.version}
+import{z as t}from"zod";function d(n,o){n.registerTool("update",{description:"Update an existing curated knowledge entry. Increments version and records the reason in the changelog.",inputSchema:{path:t.string().describe('Relative path within curated/ (e.g., "decisions/use-lancedb.md")'),content:t.string().min(10).describe("New markdown content to replace existing content"),reason:t.string().min(3).describe("Why this update is being made (recorded in changelog)")}},async({path:a,content:s,reason:r})=>{try{const e=await o.update(a,s,r);return{content:[{type:"text",text:`Updated: \`curated/${e.path}\` \u2192 version ${e.version}
 
-Reason: ${reason}
+Reason: ${r}
 
 ---
-_Next: Use \`read\` to verify the updated content, or \`search\` to test searchability._`
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] Update failed:", err);
-        return {
-          content: [{ type: "text", text: `Update failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerUpdateTool
-};
-//# sourceMappingURL=update.tool.js.map
+_Next: Use \`read\` to verify the updated content, or \`search\` to test searchability._`}]}}catch(e){return console.error("[KB] Update failed:",e),{content:[{type:"text",text:`Update failed: ${e.message}`}],isError:!0}}})}export{d as registerUpdateTool};

package/packages/server/dist/tools/utility.tools.js

@@ -1,461 +1,24 @@
-import {
-  changelog,
-  encode,
-  envInfo,
-  httpRequest,
-  measure,
-  regexTest,
-  schemaValidate,
-  snippet,
-  timeUtils,
-  webSearch
-} from "@kb/tools";
-import { z } from "zod";
-function registerWebSearchTool(server) {
-  server.registerTool(
-    "web_search",
-    {
-      description: "PREFERRED web search \u2014 search the web via DuckDuckGo (no API key). Returns structured results with title, URL, and snippet.",
-      inputSchema: {
-        query: z.string().describe("Search query"),
-        limit: z.number().min(1).max(20).default(5).describe("Max results to return"),
-        site: z.string().optional().describe('Restrict to domain (e.g., "docs.aws.amazon.com")')
-      }
-    },
-    async ({ query, limit, site }) => {
-      try {
-        const result = await webSearch({ query, limit, site });
-        const lines = [`## Search: ${result.query}`, ""];
-        if (result.results.length === 0) {
-          lines.push("No results found.");
-        } else {
-          for (const r of result.results) {
-            lines.push(`### [${r.title}](${r.url})`, r.snippet, "");
-          }
-        }
-        lines.push("---", "_Next: Use `web_fetch` to read any of these pages in full._");
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Web search failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerHttpTool(server) {
-  server.registerTool(
-    "http",
-    {
-      description: "Make HTTP requests (GET/POST/PUT/PATCH/DELETE/HEAD) for API testing. Returns status, headers, and formatted body with timing info.",
-      inputSchema: {
-        url: z.string().url().describe("Request URL (http/https only)"),
-        method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]).default("GET").describe("HTTP method"),
-        headers: z.record(z.string(), z.string()).optional().describe("Request headers as key-value pairs"),
-        body: z.string().optional().describe("Request body (for POST/PUT/PATCH)"),
-        timeout: z.number().min(1e3).max(6e4).default(15e3).describe("Timeout in milliseconds")
-      }
-    },
-    async ({ url, method, headers, body, timeout }) => {
-      try {
-        const result = await httpRequest({
-          url,
-          method,
-          headers,
-          body,
-          timeout
-        });
-        const lines = [
-          `## ${method} ${url}`,
-          "",
-          `**Status:** ${result.status} ${result.statusText}`,
-          `**Time:** ${result.durationMs}ms`,
-          `**Size:** ${result.sizeBytes} bytes`,
-          `**Content-Type:** ${result.contentType}`,
-          "",
-          "### Headers",
-          "```json",
-          JSON.stringify(result.headers, null, 2),
-          "```",
-          "",
-          "### Body",
-          result.contentType.includes("json") ? "```json" : "```",
-          result.body,
-          "```"
-        ];
-        if (result.truncated) {
-          lines.push("", `_Response truncated \u2014 total size: ${result.sizeBytes} bytes_`);
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `HTTP request failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerRegexTestTool(server) {
-  server.registerTool(
-    "regex_test",
-    {
-      description: "Test a regex pattern against sample strings. Supports match, replace, and split modes.",
-      inputSchema: {
-        pattern: z.string().describe("Regex pattern (without delimiters)"),
-        flags: z.string().default("").describe("Regex flags (g, i, m, s, etc.)"),
-        test_strings: z.array(z.string()).describe("Strings to test the pattern against"),
-        mode: z.enum(["match", "replace", "split"]).default("match").describe("Test mode"),
-        replacement: z.string().optional().describe("Replacement string (for replace mode)")
-      }
-    },
-    async ({ pattern, flags, test_strings, mode, replacement }) => {
-      const result = regexTest({
-        pattern,
-        flags,
-        testStrings: test_strings,
-        mode,
-        replacement
-      });
-      if (!result.valid) {
-        return {
-          content: [{ type: "text", text: `Invalid regex: ${result.error}` }],
-          isError: true
-        };
-      }
-      const lines = [`## Regex: \`/${result.pattern}/${result.flags}\``, "", `Mode: ${mode}`, ""];
-      for (const r of result.results) {
-        lines.push(`**Input:** \`${r.input}\``);
-        lines.push(`**Matched:** ${r.matched}`);
-        if (r.matches) {
-          for (const m of r.matches) {
-            const groups = m.groups.length > 0 ? ` groups: [${m.groups.join(", ")}]` : "";
-            lines.push(`  - "${m.full}" at index ${m.index}${groups}`);
-          }
-        }
-        if (r.replaced !== void 0) lines.push(`**Result:** \`${r.replaced}\``);
-        if (r.split) lines.push(`**Split:** ${JSON.stringify(r.split)}`);
-        lines.push("");
-      }
-      return { content: [{ type: "text", text: lines.join("\n") }] };
-    }
-  );
-}
-function registerEncodeTool(server) {
-  server.registerTool(
-    "encode",
-    {
-      description: "Encode, decode, or hash text. Supports base64, URL encoding, SHA-256, MD5, JWT decode, hex.",
-      inputSchema: {
-        operation: z.enum([
-          "base64_encode",
-          "base64_decode",
-          "url_encode",
-          "url_decode",
-          "sha256",
-          "md5",
-          "jwt_decode",
-          "hex_encode",
-          "hex_decode"
-        ]).describe("Operation to perform"),
-        input: z.string().describe("Input text")
-      }
-    },
-    async ({ operation, input }) => {
-      try {
-        const result = encode({ operation, input });
-        return {
-          content: [
-            {
-              type: "text",
-              text: `## ${operation}
+import{changelog as g,encode as f,envInfo as h,httpRequest as y,measure as x,regexTest as $,schemaValidate as b,snippet as S,timeUtils as v,webSearch as T}from"@kb/tools";import{z as e}from"zod";function _(c){c.registerTool("web_search",{description:"PREFERRED web search \u2014 search the web via DuckDuckGo (no API key). Returns structured results with title, URL, and snippet.",inputSchema:{query:e.string().describe("Search query"),limit:e.number().min(1).max(20).default(5).describe("Max results to return"),site:e.string().optional().describe('Restrict to domain (e.g., "docs.aws.amazon.com")')}},async({query:a,limit:i,site:r})=>{try{const s=await T({query:a,limit:i,site:r}),t=[`## Search: ${s.query}`,""];if(s.results.length===0)t.push("No results found.");else for(const n of s.results)t.push(`### [${n.title}](${n.url})`,n.snippet,"");return t.push("---","_Next: Use `web_fetch` to read any of these pages in full._"),{content:[{type:"text",text:t.join(`
+`)}]}}catch(s){return{content:[{type:"text",text:`Web search failed: ${s.message}`}],isError:!0}}})}function M(c){c.registerTool("http",{description:"Make HTTP requests (GET/POST/PUT/PATCH/DELETE/HEAD) for API testing. Returns status, headers, and formatted body with timing info.",inputSchema:{url:e.string().url().describe("Request URL (http/https only)"),method:e.enum(["GET","POST","PUT","PATCH","DELETE","HEAD"]).default("GET").describe("HTTP method"),headers:e.record(e.string(),e.string()).optional().describe("Request headers as key-value pairs"),body:e.string().optional().describe("Request body (for POST/PUT/PATCH)"),timeout:e.number().min(1e3).max(6e4).default(15e3).describe("Timeout in milliseconds")}},async({url:a,method:i,headers:r,body:s,timeout:t})=>{try{const n=await y({url:a,method:i,headers:r,body:s,timeout:t}),o=[`## ${i} ${a}`,"",`**Status:** ${n.status} ${n.statusText}`,`**Time:** ${n.durationMs}ms`,`**Size:** ${n.sizeBytes} bytes`,`**Content-Type:** ${n.contentType}`,"","### Headers","```json",JSON.stringify(n.headers,null,2),"```","","### Body",n.contentType.includes("json")?"```json":"```",n.body,"```"];return n.truncated&&o.push("",`_Response truncated \u2014 total size: ${n.sizeBytes} bytes_`),{content:[{type:"text",text:o.join(`
+`)}]}}catch(n){return{content:[{type:"text",text:`HTTP request failed: ${n.message}`}],isError:!0}}})}function R(c){c.registerTool("regex_test",{description:"Test a regex pattern against sample strings. Supports match, replace, and split modes.",inputSchema:{pattern:e.string().describe("Regex pattern (without delimiters)"),flags:e.string().default("").describe("Regex flags (g, i, m, s, etc.)"),test_strings:e.array(e.string()).describe("Strings to test the pattern against"),mode:e.enum(["match","replace","split"]).default("match").describe("Test mode"),replacement:e.string().optional().describe("Replacement string (for replace mode)")}},async({pattern:a,flags:i,test_strings:r,mode:s,replacement:t})=>{const n=$({pattern:a,flags:i,testStrings:r,mode:s,replacement:t});if(!n.valid)return{content:[{type:"text",text:`Invalid regex: ${n.error}`}],isError:!0};const o=[`## Regex: \`/${n.pattern}/${n.flags}\``,"",`Mode: ${s}`,""];for(const d of n.results){if(o.push(`**Input:** \`${d.input}\``),o.push(`**Matched:** ${d.matched}`),d.matches)for(const p of d.matches){const l=p.groups.length>0?` groups: [${p.groups.join(", ")}]`:"";o.push(`  - "${p.full}" at index ${p.index}${l}`)}d.replaced!==void 0&&o.push(`**Result:** \`${d.replaced}\``),d.split&&o.push(`**Split:** ${JSON.stringify(d.split)}`),o.push("")}return{content:[{type:"text",text:o.join(`
+`)}]}})}function j(c){c.registerTool("encode",{description:"Encode, decode, or hash text. Supports base64, URL encoding, SHA-256, MD5, JWT decode, hex.",inputSchema:{operation:e.enum(["base64_encode","base64_decode","url_encode","url_decode","sha256","md5","jwt_decode","hex_encode","hex_decode"]).describe("Operation to perform"),input:e.string().describe("Input text")}},async({operation:a,input:i})=>{try{const r=f({operation:a,input:i});return{content:[{type:"text",text:`## ${a}
 
-**Input:** \`${input.length > 100 ? `${input.slice(0, 100)}...` : input}\`
+**Input:** \`${i.length>100?`${i.slice(0,100)}...`:i}\`
 **Output:**
 \`\`\`
-${result.output}
-\`\`\``
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Encode failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerMeasureTool(server) {
-  server.registerTool(
-    "measure",
-    {
-      description: "Measure code complexity, line counts, and function counts for a file or directory. Returns per-file metrics sorted by complexity.",
-      inputSchema: {
-        path: z.string().describe("File or directory path to measure"),
-        extensions: z.array(z.string()).optional().describe("File extensions to include (default: .ts,.tsx,.js,.jsx)")
-      }
-    },
-    async ({ path, extensions }) => {
-      try {
-        const result = measure({ path, extensions });
-        const lines = [
-          "## Code Metrics",
-          "",
-          `**Files:** ${result.summary.totalFiles}`,
-          `**Total lines:** ${result.summary.totalLines} (${result.summary.totalCodeLines} code)`,
-          `**Functions:** ${result.summary.totalFunctions}`,
-          `**Avg complexity:** ${result.summary.avgComplexity}`,
-          `**Max complexity:** ${result.summary.maxComplexity.value} (${result.summary.maxComplexity.file})`,
-          "",
-          "### Top files by complexity",
-          "",
-          "| File | Lines | Code | Complexity | Functions | Imports |",
-          "|------|-------|------|------------|-----------|---------|"
-        ];
-        for (const f of result.files.slice(0, 20)) {
-          lines.push(
-            `| ${f.path} | ${f.lines.total} | ${f.lines.code} | ${f.complexity} | ${f.functions} | ${f.imports} |`
-          );
-        }
-        if (result.files.length > 20) {
-          lines.push(``, `_...and ${result.files.length - 20} more files_`);
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Measure failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerChangelogTool(server) {
-  server.registerTool(
-    "changelog",
-    {
-      description: "Generate a changelog from git history between two refs. Groups by conventional commit type.",
-      inputSchema: {
-        from: z.string().describe("Start ref (tag, SHA, HEAD~N)"),
-        to: z.string().default("HEAD").describe("End ref (default: HEAD)"),
-        format: z.enum(["grouped", "chronological", "per-scope"]).default("grouped").describe("Output format"),
-        include_breaking: z.boolean().default(true).describe("Highlight breaking changes")
-      }
-    },
-    async ({ from, to, format, include_breaking }) => {
-      try {
-        const result = changelog({ from, to, format, includeBreaking: include_breaking });
-        const stats = `${result.stats.total} commits (${Object.entries(result.stats.types).map(([k, v]) => `${v} ${k}`).join(", ")})`;
-        return {
-          content: [
-            {
-              type: "text",
-              text: `${result.markdown}
+${r.output}
+\`\`\``}]}}catch(r){return{content:[{type:"text",text:`Encode failed: ${r.message}`}],isError:!0}}})}function O(c){c.registerTool("measure",{description:"Measure code complexity, line counts, and function counts for a file or directory. Returns per-file metrics sorted by complexity.",inputSchema:{path:e.string().describe("File or directory path to measure"),extensions:e.array(e.string()).optional().describe("File extensions to include (default: .ts,.tsx,.js,.jsx)")}},async({path:a,extensions:i})=>{try{const r=x({path:a,extensions:i}),s=["## Code Metrics","",`**Files:** ${r.summary.totalFiles}`,`**Total lines:** ${r.summary.totalLines} (${r.summary.totalCodeLines} code)`,`**Functions:** ${r.summary.totalFunctions}`,`**Avg complexity:** ${r.summary.avgComplexity}`,`**Max complexity:** ${r.summary.maxComplexity.value} (${r.summary.maxComplexity.file})`,"","### Top files by complexity","","| File | Lines | Code | Complexity | Functions | Imports |","|------|-------|------|------------|-----------|---------|"];for(const t of r.files.slice(0,20))s.push(`| ${t.path} | ${t.lines.total} | ${t.lines.code} | ${t.complexity} | ${t.functions} | ${t.imports} |`);return r.files.length>20&&s.push("",`_...and ${r.files.length-20} more files_`),{content:[{type:"text",text:s.join(`
+`)}]}}catch(r){return{content:[{type:"text",text:`Measure failed: ${r.message}`}],isError:!0}}})}function P(c){c.registerTool("changelog",{description:"Generate a changelog from git history between two refs. Groups by conventional commit type.",inputSchema:{from:e.string().describe("Start ref (tag, SHA, HEAD~N)"),to:e.string().default("HEAD").describe("End ref (default: HEAD)"),format:e.enum(["grouped","chronological","per-scope"]).default("grouped").describe("Output format"),include_breaking:e.boolean().default(!0).describe("Highlight breaking changes")}},async({from:a,to:i,format:r,include_breaking:s})=>{try{const t=g({from:a,to:i,format:r,includeBreaking:s}),n=`${t.stats.total} commits (${Object.entries(t.stats.types).map(([o,d])=>`${d} ${o}`).join(", ")})`;return{content:[{type:"text",text:`${t.markdown}
 ---
-_${stats}_`
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Changelog failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerSchemaValidateTool(server) {
-  server.registerTool(
-    "schema_validate",
-    {
-      description: "Validate JSON data against a JSON Schema. Supports type, required, properties, items, enum, pattern, min/max.",
-      inputSchema: {
-        data: z.string().describe("JSON data to validate (as string)"),
-        schema: z.string().describe("JSON Schema to validate against (as string)")
-      }
-    },
-    async ({ data, schema }) => {
-      try {
-        const parsedData = JSON.parse(data);
-        const parsedSchema = JSON.parse(schema);
-        const result = schemaValidate({ data: parsedData, schema: parsedSchema });
-        if (result.valid) {
-          return {
-            content: [
-              { type: "text", text: "## Validation: PASSED\n\nData matches the schema." }
-            ]
-          };
-        }
-        const lines = ["## Validation: FAILED", "", `**${result.errors.length} error(s):**`, ""];
-        for (const e of result.errors) {
-          const detail = e.expected ? ` (expected: ${e.expected}, got: ${e.received})` : "";
-          lines.push(`- \`${e.path}\`: ${e.message}${detail}`);
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [
-            { type: "text", text: `Schema validation failed: ${err.message}` }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerSnippetTool(server) {
-  server.registerTool(
-    "snippet",
-    {
-      description: "Save, retrieve, search, and manage persistent code snippets/templates.",
-      inputSchema: {
-        action: z.enum(["save", "get", "list", "search", "delete"]).describe("Operation to perform"),
-        name: z.string().optional().describe("Snippet name (required for save/get/delete)"),
-        language: z.string().optional().describe("Language tag (for save)"),
-        code: z.string().optional().describe("Code content (for save)"),
-        tags: z.array(z.string()).optional().describe("Tags for categorization (for save)"),
-        query: z.string().optional().describe("Search query (for search)")
-      }
-    },
-    async ({ action, name, language, code, tags, query }) => {
-      try {
-        const result = snippet({ action, name, language, code, tags, query });
-        if ("deleted" in result) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: result.deleted ? `Snippet "${name}" deleted.` : `Snippet "${name}" not found.`
-              }
-            ]
-          };
-        }
-        if ("snippets" in result) {
-          if (result.snippets.length === 0) {
-            return { content: [{ type: "text", text: "No snippets found." }] };
-          }
-          const lines = ["## Snippets", ""];
-          for (const s2 of result.snippets) {
-            const tagStr2 = s2.tags.length > 0 ? ` [${s2.tags.join(", ")}]` : "";
-            lines.push(`- **${s2.name}** (${s2.language})${tagStr2}`);
-          }
-          return { content: [{ type: "text", text: lines.join("\n") }] };
-        }
-        const s = result;
-        const tagStr = s.tags.length > 0 ? `
-Tags: ${s.tags.join(", ")}` : "";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `## ${s.name} (${s.language})${tagStr}
+_${n}_`}]}}catch(t){return{content:[{type:"text",text:`Changelog failed: ${t.message}`}],isError:!0}}})}function D(c){c.registerTool("schema_validate",{description:"Validate JSON data against a JSON Schema. Supports type, required, properties, items, enum, pattern, min/max.",inputSchema:{data:e.string().describe("JSON data to validate (as string)"),schema:e.string().describe("JSON Schema to validate against (as string)")}},async({data:a,schema:i})=>{try{const r=JSON.parse(a),s=JSON.parse(i),t=b({data:r,schema:s});if(t.valid)return{content:[{type:"text",text:`## Validation: PASSED
 
-\`\`\`${s.language}
-${s.code}
-\`\`\``
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Snippet failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerEnvTool(server) {
-  server.registerTool(
-    "env",
-    {
-      description: "Get system and runtime environment info. Sensitive env vars are redacted by default.",
-      inputSchema: {
-        include_env: z.boolean().default(false).describe("Include environment variables"),
-        filter_env: z.string().optional().describe("Filter env vars by name substring"),
-        show_sensitive: z.boolean().default(false).describe("Show sensitive values (keys, tokens, etc.) \u2014 redacted by default")
-      }
-    },
-    async ({ include_env, filter_env, show_sensitive }) => {
-      const result = envInfo({
-        includeEnv: include_env,
-        filterEnv: filter_env,
-        showSensitive: show_sensitive
-      });
-      const lines = [
-        "## Environment",
-        "",
-        `**Platform:** ${result.system.platform} ${result.system.arch}`,
-        `**OS:** ${result.system.type} ${result.system.release}`,
-        `**Host:** ${result.system.hostname}`,
-        `**CPUs:** ${result.system.cpus}`,
-        `**Memory:** ${result.system.memoryFreeGb}GB free / ${result.system.memoryTotalGb}GB total`,
-        "",
-        `**Node:** ${result.runtime.node}`,
-        `**V8:** ${result.runtime.v8}`,
-        `**CWD:** ${result.cwd}`
-      ];
-      if (result.env) {
-        lines.push("", "### Environment Variables", "");
-        for (const [key, value] of Object.entries(result.env)) {
-          lines.push(`- \`${key}\`: ${value}`);
-        }
-      }
-      return { content: [{ type: "text", text: lines.join("\n") }] };
-    }
-  );
-}
-function registerTimeTool(server) {
-  server.registerTool(
-    "time",
-    {
-      description: "Parse dates, convert timezones, calculate durations, add time. Supports ISO 8601, unix timestamps, and human-readable formats.",
-      inputSchema: {
-        operation: z.enum(["now", "parse", "convert", "diff", "add"]).describe(
-          "now: current time | parse: parse a date string | convert: timezone conversion | diff: duration between two dates | add: add duration to date"
-        ),
-        input: z.string().optional().describe(
-          "Date input (ISO, unix timestamp, or parseable string). For diff: two comma-separated dates"
-        ),
-        timezone: z.string().optional().describe('Target timezone (e.g., "America/New_York", "Asia/Tokyo")'),
-        duration: z.string().optional().describe('Duration to add (e.g., "2h30m", "1d", "30s") \u2014 for add operation')
-      }
-    },
-    async ({ operation, input, timezone, duration }) => {
-      try {
-        const result = timeUtils({ operation, input, timezone, duration });
-        const lines = [`**${result.output}**`, "", `ISO: ${result.iso}`, `Unix: ${result.unix}`];
-        if (result.details) {
-          lines.push("", "```json", JSON.stringify(result.details, null, 2), "```");
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Time failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerChangelogTool,
-  registerEncodeTool,
-  registerEnvTool,
-  registerHttpTool,
-  registerMeasureTool,
-  registerRegexTestTool,
-  registerSchemaValidateTool,
-  registerSnippetTool,
-  registerTimeTool,
-  registerWebSearchTool
-};
-//# sourceMappingURL=utility.tools.js.map
+Data matches the schema.`}]};const n=["## Validation: FAILED","",`**${t.errors.length} error(s):**`,""];for(const o of t.errors){const d=o.expected?` (expected: ${o.expected}, got: ${o.received})`:"";n.push(`- \`${o.path}\`: ${o.message}${d}`)}return{content:[{type:"text",text:n.join(`
+`)}]}}catch(r){return{content:[{type:"text",text:`Schema validation failed: ${r.message}`}],isError:!0}}})}function k(c){c.registerTool("snippet",{description:"Save, retrieve, search, and manage persistent code snippets/templates.",inputSchema:{action:e.enum(["save","get","list","search","delete"]).describe("Operation to perform"),name:e.string().optional().describe("Snippet name (required for save/get/delete)"),language:e.string().optional().describe("Language tag (for save)"),code:e.string().optional().describe("Code content (for save)"),tags:e.array(e.string()).optional().describe("Tags for categorization (for save)"),query:e.string().optional().describe("Search query (for search)")}},async({action:a,name:i,language:r,code:s,tags:t,query:n})=>{try{const o=S({action:a,name:i,language:r,code:s,tags:t,query:n});if("deleted"in o)return{content:[{type:"text",text:o.deleted?`Snippet "${i}" deleted.`:`Snippet "${i}" not found.`}]};if("snippets"in o){if(o.snippets.length===0)return{content:[{type:"text",text:"No snippets found."}]};const l=["## Snippets",""];for(const u of o.snippets){const m=u.tags.length>0?` [${u.tags.join(", ")}]`:"";l.push(`- **${u.name}** (${u.language})${m}`)}return{content:[{type:"text",text:l.join(`
+`)}]}}const d=o,p=d.tags.length>0?`
+Tags: ${d.tags.join(", ")}`:"";return{content:[{type:"text",text:`## ${d.name} (${d.language})${p}
+
+\`\`\`${d.language}
+${d.code}
+\`\`\``}]}}catch(o){return{content:[{type:"text",text:`Snippet failed: ${o.message}`}],isError:!0}}})}function A(c){c.registerTool("env",{description:"Get system and runtime environment info. Sensitive env vars are redacted by default.",inputSchema:{include_env:e.boolean().default(!1).describe("Include environment variables"),filter_env:e.string().optional().describe("Filter env vars by name substring"),show_sensitive:e.boolean().default(!1).describe("Show sensitive values (keys, tokens, etc.) \u2014 redacted by default")}},async({include_env:a,filter_env:i,show_sensitive:r})=>{const s=h({includeEnv:a,filterEnv:i,showSensitive:r}),t=["## Environment","",`**Platform:** ${s.system.platform} ${s.system.arch}`,`**OS:** ${s.system.type} ${s.system.release}`,`**Host:** ${s.system.hostname}`,`**CPUs:** ${s.system.cpus}`,`**Memory:** ${s.system.memoryFreeGb}GB free / ${s.system.memoryTotalGb}GB total`,"",`**Node:** ${s.runtime.node}`,`**V8:** ${s.runtime.v8}`,`**CWD:** ${s.cwd}`];if(s.env){t.push("","### Environment Variables","");for(const[n,o]of Object.entries(s.env))t.push(`- \`${n}\`: ${o}`)}return{content:[{type:"text",text:t.join(`
+`)}]}})}function H(c){c.registerTool("time",{description:"Parse dates, convert timezones, calculate durations, add time. Supports ISO 8601, unix timestamps, and human-readable formats.",inputSchema:{operation:e.enum(["now","parse","convert","diff","add"]).describe("now: current time | parse: parse a date string | convert: timezone conversion | diff: duration between two dates | add: add duration to date"),input:e.string().optional().describe("Date input (ISO, unix timestamp, or parseable string). For diff: two comma-separated dates"),timezone:e.string().optional().describe('Target timezone (e.g., "America/New_York", "Asia/Tokyo")'),duration:e.string().optional().describe('Duration to add (e.g., "2h30m", "1d", "30s") \u2014 for add operation')}},async({operation:a,input:i,timezone:r,duration:s})=>{try{const t=v({operation:a,input:i,timezone:r,duration:s}),n=[`**${t.output}**`,"",`ISO: ${t.iso}`,`Unix: ${t.unix}`];return t.details&&n.push("","```json",JSON.stringify(t.details,null,2),"```"),{content:[{type:"text",text:n.join(`
+`)}]}}catch(t){return{content:[{type:"text",text:`Time failed: ${t.message}`}],isError:!0}}})}export{P as registerChangelogTool,j as registerEncodeTool,A as registerEnvTool,M as registerHttpTool,O as registerMeasureTool,R as registerRegexTestTool,D as registerSchemaValidateTool,k as registerSnippetTool,H as registerTimeTool,_ as registerWebSearchTool};

package/packages/store/dist/graph-store.interface.js

@@ -1 +0,0 @@
-//# sourceMappingURL=graph-store.interface.js.map

package/packages/store/dist/index.js

@@ -1,9 +1 @@
-import { LanceStore } from "./lance-store.js";
-import { SqliteGraphStore } from "./sqlite-graph-store.js";
-import { createStore } from "./store-factory.js";
-export {
-  LanceStore,
-  SqliteGraphStore,
-  createStore
-};
-//# sourceMappingURL=index.js.map
+import{LanceStore as t}from"./lance-store.js";import{SqliteGraphStore as a}from"./sqlite-graph-store.js";import{createStore as s}from"./store-factory.js";export{t as LanceStore,a as SqliteGraphStore,s as createStore};