@lmthing/repl 0.0.1

package/dist/crypto-BTVPQPPV.js

@@ -0,0 +1,45 @@
+// src/catalog/crypto.ts
+import { createHash, randomBytes as nodeRandomBytes, randomUUID } from "crypto";
+var cryptoModule = {
+  id: "crypto",
+  description: "Cryptographic utilities",
+  functions: [
+    {
+      name: "hash",
+      description: "Hash a string",
+      signature: "(data: string, algorithm?: 'sha256' | 'sha512' | 'md5') => string",
+      fn: (data, algorithm) => {
+        const algo = algorithm || "sha256";
+        return createHash(algo).update(data).digest("hex");
+      }
+    },
+    {
+      name: "randomBytes",
+      description: "Random hex string",
+      signature: "(length: number) => string",
+      fn: (length) => nodeRandomBytes(length).toString("hex")
+    },
+    {
+      name: "uuid",
+      description: "Generate UUID v4",
+      signature: "() => string",
+      fn: () => randomUUID()
+    },
+    {
+      name: "base64Encode",
+      description: "Encode to base64",
+      signature: "(data: string) => string",
+      fn: (data) => Buffer.from(data).toString("base64")
+    },
+    {
+      name: "base64Decode",
+      description: "Decode from base64",
+      signature: "(data: string) => string",
+      fn: (data) => Buffer.from(data, "base64").toString("utf-8")
+    }
+  ]
+};
+var crypto_default = cryptoModule;
+export {
+  crypto_default as default
+};

package/dist/csv-3IL3IKAY.js

@@ -0,0 +1,115 @@
+// src/catalog/csv.ts
+import { readFile, writeFile } from "fs/promises";
+function parseCsv(text, options) {
+  const delimiter = options?.delimiter ?? ",";
+  const hasHeader = options?.header !== false;
+  const lines = text.trim().split("\n");
+  if (lines.length === 0) return [];
+  const parseRow = (line) => {
+    const values = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (inQuotes) {
+        if (ch === '"') {
+          if (line[i + 1] === '"') {
+            current += '"';
+            i++;
+          } else {
+            inQuotes = false;
+          }
+        } else {
+          current += ch;
+        }
+      } else if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === delimiter) {
+        values.push(current.trim());
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+    values.push(current.trim());
+    return values;
+  };
+  if (hasHeader && lines.length > 1) {
+    const headers = parseRow(lines[0]);
+    return lines.slice(1).filter((l) => l.trim()).map((line) => {
+      const values = parseRow(line);
+      const obj = {};
+      headers.forEach((h, i) => {
+        obj[h] = values[i] ?? "";
+      });
+      return obj;
+    });
+  }
+  return lines.filter((l) => l.trim()).map(parseRow);
+}
+function stringifyCsv(data, options) {
+  const delimiter = options?.delimiter ?? ",";
+  const showHeader = options?.header !== false;
+  if (data.length === 0) return "";
+  const first = data[0];
+  if (typeof first === "object" && first !== null && !Array.isArray(first)) {
+    const keys = Object.keys(first);
+    const lines = [];
+    if (showHeader) lines.push(keys.join(delimiter));
+    for (const row of data) {
+      const obj = row;
+      lines.push(keys.map((k) => escCsvVal(String(obj[k] ?? ""), delimiter)).join(delimiter));
+    }
+    return lines.join("\n");
+  }
+  return data.map((row) => {
+    if (Array.isArray(row)) return row.map((v) => escCsvVal(String(v), delimiter)).join(delimiter);
+    return String(row);
+  }).join("\n");
+}
+function escCsvVal(val, delimiter) {
+  if (val.includes(delimiter) || val.includes('"') || val.includes("\n")) {
+    return `"${val.replace(/"/g, '""')}"`;
+  }
+  return val;
+}
+var csvModule = {
+  id: "csv",
+  description: "CSV processing",
+  functions: [
+    {
+      name: "csvParse",
+      description: "Parse CSV to array of objects/arrays",
+      signature: "(text: string, options?: { header?: boolean, delimiter?: string }) => any[]",
+      fn: (text, options) => parseCsv(text, options)
+    },
+    {
+      name: "csvStringify",
+      description: "Convert to CSV string",
+      signature: "(data: any[], options?: { header?: boolean, delimiter?: string }) => string",
+      fn: (data, options) => stringifyCsv(data, options)
+    },
+    {
+      name: "csvReadFile",
+      description: "Read and parse CSV file",
+      signature: "(path: string, options?: CsvOptions) => Promise<any[]>",
+      fn: async (path, options) => {
+        const text = await readFile(path, "utf-8");
+        return parseCsv(text, options);
+      }
+    },
+    {
+      name: "csvWriteFile",
+      description: "Write data as CSV file",
+      signature: "(path: string, data: any[], options?: CsvOptions) => Promise<void>",
+      fn: async (path, data, options) => {
+        const text = stringifyCsv(data, options);
+        await writeFile(path, text, "utf-8");
+      }
+    }
+  ]
+};
+var csv_default = csvModule;
+export {
+  csv_default as default
+};

package/dist/date-DL6PIRCI.js

@@ -0,0 +1,56 @@
+// src/catalog/date.ts
+function formatDateStr(date, format) {
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  return format.replace("YYYY", String(date.getFullYear())).replace("MM", pad(date.getMonth() + 1)).replace("DD", pad(date.getDate())).replace("HH", pad(date.getHours())).replace("mm", pad(date.getMinutes())).replace("ss", pad(date.getSeconds()));
+}
+var dateModule = {
+  id: "date",
+  description: "Date/time utilities",
+  functions: [
+    {
+      name: "now",
+      description: "Current ISO 8601 timestamp",
+      signature: "() => string",
+      fn: () => (/* @__PURE__ */ new Date()).toISOString()
+    },
+    {
+      name: "parseDate",
+      description: "Parse date string",
+      signature: "(input: string) => Date",
+      fn: (input) => new Date(input)
+    },
+    {
+      name: "formatDate",
+      description: 'Format date (e.g., "YYYY-MM-DD")',
+      signature: "(date: Date | string, format: string) => string",
+      fn: (date, format) => {
+        const d = date instanceof Date ? date : new Date(date);
+        return formatDateStr(d, format);
+      }
+    },
+    {
+      name: "addDays",
+      description: "Date arithmetic \u2014 add days",
+      signature: "(date: Date | string, days: number) => Date",
+      fn: (date, days) => {
+        const d = date instanceof Date ? new Date(date) : new Date(date);
+        d.setDate(d.getDate() + days);
+        return d;
+      }
+    },
+    {
+      name: "diffDays",
+      description: "Days between two dates",
+      signature: "(a: Date | string, b: Date | string) => number",
+      fn: (a, b) => {
+        const da = a instanceof Date ? a : new Date(a);
+        const db = b instanceof Date ? b : new Date(b);
+        return Math.round((db.getTime() - da.getTime()) / (1e3 * 60 * 60 * 24));
+      }
+    }
+  ]
+};
+var date_default = dateModule;
+export {
+  date_default as default
+};

package/dist/db-IVNVHDFE.js

@@ -0,0 +1,68 @@
+// src/catalog/db.ts
+async function getSqlite() {
+  try {
+    return (await import("better-sqlite3")).default;
+  } catch {
+    throw new Error("better-sqlite3 is required for database operations. Install with: pnpm add better-sqlite3");
+  }
+}
+var dbInstance = null;
+var dbPath = "./repl.db";
+function setDbPath(path) {
+  dbPath = path;
+  dbInstance = null;
+}
+async function getDb() {
+  if (!dbInstance) {
+    const Database = await getSqlite();
+    dbInstance = new Database(dbPath);
+  }
+  return dbInstance;
+}
+var dbModule = {
+  id: "db",
+  description: "Database queries (SQLite)",
+  functions: [
+    {
+      name: "dbQuery",
+      description: "Run SELECT query, return rows",
+      signature: "(sql: string, params?: any[]) => Promise<any[]>",
+      fn: async (sql, params) => {
+        const db = await getDb();
+        const stmt = db.prepare(sql);
+        return stmt.all(...params ?? []);
+      }
+    },
+    {
+      name: "dbExecute",
+      description: "Run INSERT/UPDATE/DELETE",
+      signature: "(sql: string, params?: any[]) => Promise<{ changes: number }>",
+      fn: async (sql, params) => {
+        const db = await getDb();
+        const stmt = db.prepare(sql);
+        const result = stmt.run(...params ?? []);
+        return { changes: result.changes };
+      }
+    },
+    {
+      name: "dbSchema",
+      description: "Get database schema",
+      signature: "() => Promise<{ tables: Array<{ name: string, columns: any[] }> }>",
+      fn: async () => {
+        const db = await getDb();
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+        const result = [];
+        for (const table of tables) {
+          const columns = db.prepare(`PRAGMA table_info(${table.name})`).all();
+          result.push({ name: table.name, columns });
+        }
+        return { tables: result };
+      }
+    }
+  ]
+};
+var db_default = dbModule;
+export {
+  db_default as default,
+  setDbPath
+};

package/dist/env-PPLEQ47H.js

@@ -0,0 +1,47 @@
+// src/catalog/env.ts
+var SECRET_PATTERNS = [/_KEY$/, /_SECRET$/, /_TOKEN$/, /_PASSWORD$/, /^PASSWORD$/, /^SECRET$/];
+var DEFAULT_ALLOW = ["HOME", "USER", "PATH", "LANG", "TERM", "SHELL", "EDITOR", "NODE_ENV"];
+var ALLOW_PREFIXES = ["LMTHING_"];
+var customAllowlist = null;
+function setEnvAllowlist(names) {
+  customAllowlist = new Set(names);
+}
+function isAllowed(key) {
+  if (customAllowlist?.has(key)) return true;
+  if (DEFAULT_ALLOW.includes(key)) return true;
+  if (ALLOW_PREFIXES.some((p) => key.startsWith(p))) return true;
+  if (SECRET_PATTERNS.some((p) => p.test(key))) return false;
+  return false;
+}
+function getAllowedKeys() {
+  return Object.keys(process.env).filter(isAllowed).sort();
+}
+var envModule = {
+  id: "env",
+  description: "Environment variable access (allowlisted)",
+  functions: [
+    {
+      name: "getEnv",
+      description: "Read environment variable (allowlisted only)",
+      signature: "(key: string) => string | undefined",
+      fn: (key) => {
+        const k = key;
+        if (!isAllowed(k)) {
+          throw new Error(`Environment variable ${k} is not in the allowlist`);
+        }
+        return process.env[k];
+      }
+    },
+    {
+      name: "listEnv",
+      description: "List available (allowlisted) variable names",
+      signature: "() => string[]",
+      fn: () => getAllowedKeys()
+    }
+  ]
+};
+var env_default = envModule;
+export {
+  env_default as default,
+  setEnvAllowlist
+};

package/dist/fetch-TN4ZJVQW.js

@@ -0,0 +1,118 @@
+// src/catalog/fetch.ts
+import { writeFile } from "fs/promises";
+var fetchModule = {
+  id: "fetch",
+  description: "HTTP request utilities",
+  functions: [
+    {
+      name: "httpGet",
+      description: "GET request, auto-parses JSON",
+      signature: "(url: string, headers?: Record<string, string>) => Promise<any>",
+      fn: async (url, headers) => {
+        const res = await fetch(url, { headers });
+        const contentType = res.headers.get("content-type") ?? "";
+        if (contentType.includes("json")) return res.json();
+        return res.text();
+      }
+    },
+    {
+      name: "httpPost",
+      description: "POST with JSON body",
+      signature: "(url: string, body: any, headers?: Record<string, string>) => Promise<any>",
+      fn: async (url, body, headers) => {
+        const res = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...headers },
+          body: JSON.stringify(body)
+        });
+        const ct = res.headers.get("content-type") ?? "";
+        if (ct.includes("json")) return res.json();
+        return res.text();
+      }
+    },
+    {
+      name: "httpPut",
+      description: "PUT with JSON body",
+      signature: "(url: string, body: any, headers?: Record<string, string>) => Promise<any>",
+      fn: async (url, body, headers) => {
+        const res = await fetch(url, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json", ...headers },
+          body: JSON.stringify(body)
+        });
+        const ct = res.headers.get("content-type") ?? "";
+        if (ct.includes("json")) return res.json();
+        return res.text();
+      }
+    },
+    {
+      name: "httpDelete",
+      description: "DELETE request",
+      signature: "(url: string, headers?: Record<string, string>) => Promise<any>",
+      fn: async (url, headers) => {
+        const res = await fetch(url, {
+          method: "DELETE",
+          headers
+        });
+        const ct = res.headers.get("content-type") ?? "";
+        if (ct.includes("json")) return res.json();
+        return res.text();
+      }
+    },
+    {
+      name: "httpRequest",
+      description: "Full control HTTP request",
+      signature: "(options: RequestOptions) => Promise<{ status: number, headers: Record<string, string>, body: any }>",
+      fn: async (options) => {
+        const opts = options;
+        const res = await fetch(opts.url, {
+          method: opts.method ?? "GET",
+          headers: opts.headers,
+          body: opts.body ? JSON.stringify(opts.body) : void 0,
+          signal: opts.timeout ? AbortSignal.timeout(opts.timeout) : void 0
+        });
+        const ct = res.headers.get("content-type") ?? "";
+        const body = ct.includes("json") ? await res.json() : await res.text();
+        const headers = {};
+        res.headers.forEach((v, k) => {
+          headers[k] = v;
+        });
+        return { status: res.status, headers, body };
+      }
+    },
+    {
+      name: "fetchPage",
+      description: "Fetch webpage, extract readable text",
+      signature: "(url: string) => Promise<{ title: string, text: string, links: string[] }>",
+      fn: async (url) => {
+        const res = await fetch(url);
+        const html = await res.text();
+        const titleMatch = html.match(/<title[^>]*>(.*?)<\/title>/is);
+        const title = titleMatch ? titleMatch[1].trim() : "";
+        const text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+        const links = [];
+        const linkRegex = /href=["']([^"']+)["']/gi;
+        let match;
+        while ((match = linkRegex.exec(html)) !== null) {
+          links.push(match[1]);
+        }
+        return { title, text: text.slice(0, 1e4), links: [...new Set(links)] };
+      }
+    },
+    {
+      name: "downloadFile",
+      description: "Download to local file",
+      signature: "(url: string, dest: string) => Promise<{ size: number }>",
+      fn: async (url, dest) => {
+        const res = await fetch(url);
+        const buffer = Buffer.from(await res.arrayBuffer());
+        await writeFile(dest, buffer);
+        return { size: buffer.length };
+      }
+    }
+  ]
+};
+var fetch_default = fetchModule;
+export {
+  fetch_default as default
+};

package/dist/fs-QRXDDXB5.js

@@ -0,0 +1,127 @@
+// src/catalog/fs.ts
+import * as nodeFs from "fs/promises";
+import * as nodePath from "path";
+import { glob as nodeGlob } from "fs/promises";
+var workingDir = process.cwd();
+function setWorkingDir(dir) {
+  workingDir = dir;
+}
+function safePath(p) {
+  const resolved = nodePath.resolve(workingDir, p);
+  if (!resolved.startsWith(workingDir)) {
+    throw new Error(`Path traversal blocked: ${p} resolves outside working directory`);
+  }
+  return resolved;
+}
+var fsModule = {
+  id: "fs",
+  description: "File system operations",
+  functions: [
+    {
+      name: "readFile",
+      description: "Read file contents",
+      signature: "(path: string, encoding?: string) => Promise<string>",
+      fn: async (path, encoding) => {
+        return nodeFs.readFile(safePath(path), encoding || "utf-8");
+      }
+    },
+    {
+      name: "writeFile",
+      description: "Write content to file",
+      signature: "(path: string, content: string) => Promise<void>",
+      fn: async (path, content) => {
+        await nodeFs.writeFile(safePath(path), content, "utf-8");
+      }
+    },
+    {
+      name: "appendFile",
+      description: "Append to file",
+      signature: "(path: string, content: string) => Promise<void>",
+      fn: async (path, content) => {
+        await nodeFs.appendFile(safePath(path), content, "utf-8");
+      }
+    },
+    {
+      name: "listDir",
+      description: "List directory entries",
+      signature: "(path: string, options?: { recursive?: boolean }) => Promise<string[]>",
+      fn: async (path, options) => {
+        const opts = options;
+        const entries = await nodeFs.readdir(safePath(path), { recursive: opts?.recursive });
+        return entries.map(String);
+      }
+    },
+    {
+      name: "glob",
+      description: "Glob pattern match",
+      signature: "(pattern: string, cwd?: string) => Promise<string[]>",
+      fn: async (pattern, cwd) => {
+        const dir = cwd ? safePath(cwd) : workingDir;
+        const results = [];
+        for await (const entry of nodeGlob(pattern, { cwd: dir })) {
+          results.push(entry);
+        }
+        return results;
+      }
+    },
+    {
+      name: "stat",
+      description: "File metadata",
+      signature: "(path: string) => Promise<{ size: number, modified: string, isDir: boolean }>",
+      fn: async (path) => {
+        const stats = await nodeFs.stat(safePath(path));
+        return { size: stats.size, modified: stats.mtime.toISOString(), isDir: stats.isDirectory() };
+      }
+    },
+    {
+      name: "exists",
+      description: "Check if path exists",
+      signature: "(path: string) => Promise<boolean>",
+      fn: async (path) => {
+        try {
+          await nodeFs.access(safePath(path));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    },
+    {
+      name: "mkdir",
+      description: "Create directory (recursive)",
+      signature: "(path: string) => Promise<void>",
+      fn: async (path) => {
+        await nodeFs.mkdir(safePath(path), { recursive: true });
+      }
+    },
+    {
+      name: "remove",
+      description: "Delete file or directory",
+      signature: "(path: string) => Promise<void>",
+      fn: async (path) => {
+        await nodeFs.rm(safePath(path), { recursive: true, force: true });
+      }
+    },
+    {
+      name: "copy",
+      description: "Copy file or directory",
+      signature: "(src: string, dest: string) => Promise<void>",
+      fn: async (src, dest) => {
+        await nodeFs.cp(safePath(src), safePath(dest), { recursive: true });
+      }
+    },
+    {
+      name: "move",
+      description: "Move/rename file or directory",
+      signature: "(src: string, dest: string) => Promise<void>",
+      fn: async (src, dest) => {
+        await nodeFs.rename(safePath(src), safePath(dest));
+      }
+    }
+  ]
+};
+var fs_default = fsModule;
+export {
+  fs_default as default,
+  setWorkingDir
+};

package/dist/image-FGNY3CMJ.js

@@ -0,0 +1,56 @@
+// src/catalog/image.ts
+async function getSharp() {
+  try {
+    return (await import("sharp")).default;
+  } catch {
+    throw new Error("sharp is required for image operations. Install with: pnpm add sharp");
+  }
+}
+var imageModule = {
+  id: "image",
+  description: "Image operations (requires sharp)",
+  functions: [
+    {
+      name: "imageResize",
+      description: "Resize image",
+      signature: "(src: string, dest: string, options: { width?: number, height?: number }) => Promise<void>",
+      fn: async (src, dest, options) => {
+        const sharp = await getSharp();
+        const opts = options;
+        await sharp(src).resize(opts.width, opts.height).toFile(dest);
+      }
+    },
+    {
+      name: "imageCrop",
+      description: "Crop image",
+      signature: "(src: string, dest: string, region: { left: number, top: number, width: number, height: number }) => Promise<void>",
+      fn: async (src, dest, region) => {
+        const sharp = await getSharp();
+        await sharp(src).extract(region).toFile(dest);
+      }
+    },
+    {
+      name: "imageConvert",
+      description: "Convert image format",
+      signature: "(src: string, dest: string, format: 'png' | 'jpg' | 'webp') => Promise<void>",
+      fn: async (src, dest, format) => {
+        const sharp = await getSharp();
+        await sharp(src).toFormat(format).toFile(dest);
+      }
+    },
+    {
+      name: "imageInfo",
+      description: "Image metadata",
+      signature: "(src: string) => Promise<{ width: number, height: number, format: string, size: number }>",
+      fn: async (src) => {
+        const sharp = await getSharp();
+        const meta = await sharp(src).metadata();
+        return { width: meta.width, height: meta.height, format: meta.format, size: meta.size };
+      }
+    }
+  ]
+};
+var image_default = imageModule;
+export {
+  image_default as default
+};