@lmthing/repl 0.0.1

package/dist/json-VPTMTXR6.js

@@ -0,0 +1,113 @@
+// src/catalog/json.ts
+function queryPath(data, path) {
+  const parts = path.replace(/^\$\.?/, "").split(".").filter(Boolean);
+  let current = data;
+  for (const part of parts) {
+    if (current == null) return void 0;
+    const arrayMatch = part.match(/^(\w+)\[(\*|\d+)\]$/);
+    if (arrayMatch) {
+      const [, key, index] = arrayMatch;
+      current = current[key];
+      if (!Array.isArray(current)) return void 0;
+      if (index === "*") return current;
+      current = current[parseInt(index, 10)];
+    } else {
+      current = current[part];
+    }
+  }
+  return current;
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+      for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+          result[key] = deepMerge(result[key], value);
+        } else {
+          result[key] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function diff(a, b, path = "$") {
+  const diffs = [];
+  if (a === b) return diffs;
+  if (typeof a !== typeof b || a === null || b === null || typeof a !== "object") {
+    diffs.push({ path, type: "changed", oldValue: a, newValue: b });
+    return diffs;
+  }
+  const aObj = a;
+  const bObj = b;
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(aObj), ...Object.keys(bObj)]);
+  for (const key of allKeys) {
+    if (!(key in aObj)) {
+      diffs.push({ path: `${path}.${key}`, type: "added", newValue: bObj[key] });
+    } else if (!(key in bObj)) {
+      diffs.push({ path: `${path}.${key}`, type: "removed", oldValue: aObj[key] });
+    } else {
+      diffs.push(...diff(aObj[key], bObj[key], `${path}.${key}`));
+    }
+  }
+  return diffs;
+}
+var jsonModule = {
+  id: "json",
+  description: "JSON manipulation utilities",
+  functions: [
+    {
+      name: "jsonParse",
+      description: "Parse JSON with better error messages",
+      signature: "(text: string) => any",
+      fn: (text) => {
+        try {
+          return JSON.parse(text);
+        } catch (e) {
+          const err = e;
+          throw new Error(`JSON parse error: ${err.message}`);
+        }
+      }
+    },
+    {
+      name: "jsonQuery",
+      description: "JSONPath query",
+      signature: "(data: any, path: string) => any",
+      fn: (data, path) => queryPath(data, path)
+    },
+    {
+      name: "jsonTransform",
+      description: "Map over arrays/objects",
+      signature: "(data: any, fn: (item: any) => any) => any",
+      fn: (data, fn) => {
+        const mapper = fn;
+        if (Array.isArray(data)) return data.map(mapper);
+        if (typeof data === "object" && data !== null) {
+          const result = {};
+          for (const [k, v] of Object.entries(data)) {
+            result[k] = mapper(v);
+          }
+          return result;
+        }
+        return mapper(data);
+      }
+    },
+    {
+      name: "jsonMerge",
+      description: "Deep merge objects",
+      signature: "(...objects: any[]) => any",
+      fn: (...objects) => deepMerge(...objects)
+    },
+    {
+      name: "jsonDiff",
+      description: "Structural diff between two objects",
+      signature: "(a: any, b: any) => Diff[]",
+      fn: (a, b) => diff(a, b)
+    }
+  ]
+};
+var json_default = jsonModule;
+export {
+  json_default as default
+};

package/dist/path-K3VLZVTH.js

@@ -0,0 +1,54 @@
+// src/catalog/path.ts
+import nodePath from "path";
+var pathModule = {
+  id: "path",
+  description: "Path manipulation utilities",
+  functions: [
+    {
+      name: "joinPath",
+      description: "Join path segments",
+      signature: "(...segments: string[]) => string",
+      fn: (...segments) => nodePath.join(...segments)
+    },
+    {
+      name: "resolvePath",
+      description: "Resolve to absolute path",
+      signature: "(...segments: string[]) => string",
+      fn: (...segments) => nodePath.resolve(...segments)
+    },
+    {
+      name: "relativePath",
+      description: "Relative path between two paths",
+      signature: "(from: string, to: string) => string",
+      fn: (from, to) => nodePath.relative(from, to)
+    },
+    {
+      name: "parsePath",
+      description: "Parse path components",
+      signature: "(p: string) => { dir: string, base: string, ext: string, name: string }",
+      fn: (p) => nodePath.parse(p)
+    },
+    {
+      name: "dirname",
+      description: "Directory name",
+      signature: "(p: string) => string",
+      fn: (p) => nodePath.dirname(p)
+    },
+    {
+      name: "basename",
+      description: "Base name",
+      signature: "(p: string, ext?: string) => string",
+      fn: (p, ext) => nodePath.basename(p, ext)
+    },
+    {
+      name: "extname",
+      description: "Extension",
+      signature: "(p: string) => string",
+      fn: (p) => nodePath.extname(p)
+    }
+  ]
+};
+var path_default = pathModule;
+export {
+  path_default as default
+};

package/dist/shell-NAGRIUA4.js

@@ -0,0 +1,102 @@
+// src/catalog/shell.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var shellCwd = process.cwd();
+function setShellCwd(dir) {
+  shellCwd = dir;
+}
+var shellModule = {
+  id: "shell",
+  description: "Shell command execution",
+  functions: [
+    {
+      name: "exec",
+      description: "Run shell command",
+      signature: "(command: string, options?: { cwd?: string, timeout?: number }) => Promise<{ stdout: string, stderr: string, exitCode: number }>",
+      fn: async (command, options) => {
+        const opts = options;
+        const args = command.split(" ");
+        const cmd = args[0];
+        const cmdArgs = args.slice(1);
+        try {
+          const { stdout, stderr } = await execFileAsync(cmd, cmdArgs, {
+            cwd: opts?.cwd ?? shellCwd,
+            timeout: opts?.timeout ?? 3e4
+          });
+          return { stdout, stderr, exitCode: 0 };
+        } catch (err) {
+          return {
+            stdout: err.stdout ?? "",
+            stderr: err.stderr ?? err.message,
+            exitCode: err.code ?? 1
+          };
+        }
+      }
+    },
+    {
+      name: "execLive",
+      description: "Streaming command output",
+      signature: "(command: string, options?: { cwd?: string, timeout?: number }) => AsyncIterable<{ stream: 'stdout' | 'stderr', data: string }>",
+      fn: (command, options) => {
+        const opts = options;
+        const args = command.split(" ");
+        const cmd = args[0];
+        const cmdArgs = args.slice(1);
+        return {
+          async *[Symbol.asyncIterator]() {
+            const child = spawn(cmd, cmdArgs, {
+              cwd: opts?.cwd ?? shellCwd,
+              timeout: opts?.timeout ?? 3e4
+            });
+            const chunks = [];
+            let resolve = null;
+            let done = false;
+            child.stdout?.on("data", (data) => {
+              chunks.push({ stream: "stdout", data: data.toString() });
+              resolve?.();
+            });
+            child.stderr?.on("data", (data) => {
+              chunks.push({ stream: "stderr", data: data.toString() });
+              resolve?.();
+            });
+            child.on("close", () => {
+              done = true;
+              resolve?.();
+            });
+            child.on("error", () => {
+              done = true;
+              resolve?.();
+            });
+            while (!done || chunks.length > 0) {
+              if (chunks.length === 0 && !done) {
+                await new Promise((r) => {
+                  resolve = r;
+                });
+              }
+              while (chunks.length > 0) yield chunks.shift();
+            }
+          }
+        };
+      }
+    },
+    {
+      name: "which",
+      description: "Find binary in PATH",
+      signature: "(binary: string) => Promise<string | null>",
+      fn: async (binary) => {
+        try {
+          const { stdout } = await execFileAsync("which", [binary]);
+          return stdout.trim() || null;
+        } catch {
+          return null;
+        }
+      }
+    }
+  ]
+};
+var shell_default = shellModule;
+export {
+  shell_default as default,
+  setShellCwd
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@lmthing/repl",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "pnpm build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ai": "^6.0.86",
+    "react": "^19.0.0",
+    "typescript": "^5.7.0",
+    "zod": "^4.1.13"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^11.0.0",
+    "sharp": "^0.33.0"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.10.0",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "vitest": "catalog:"
+  }
+}