@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-GAZEWQEZ.js

@@ -0,0 +1,231 @@
+import {
+  DefaultPromptStore,
+  migratePromptEntry
+} from "./chunk-GFXZTHNI.js";
+import {
+  PROMPT_CATEGORY_LABELS,
+  isBuiltinCategory
+} from "./chunk-KDQJCT2J.js";
+
+// src/execution/prompt-loader.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var DefaultPromptLoader = class {
+  projectStore;
+  userStore;
+  builtinDir;
+  cache;
+  builtinCache;
+  constructor(opts) {
+    this.projectStore = typeof opts.paths.inProjectPrompts === "string" ? new DefaultPromptStore(opts.paths.inProjectPrompts) : void 0;
+    this.userStore = typeof opts.paths.globalPrompts === "string" ? new DefaultPromptStore(opts.paths.globalPrompts) : void 0;
+    this.builtinDir = opts.bundledDir ? path.join(opts.bundledDir, "prompts") : void 0;
+  }
+  async list() {
+    if (this.cache) return this.cache;
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    const layers = [
+      (await (this.projectStore?.list() ?? Promise.resolve([]))).map((e) => ({
+        ...e,
+        source: "project"
+      })),
+      await (this.userStore?.list() ?? Promise.resolve([])),
+      // keeps stored source ('user' or 'synced')
+      await this.readBuiltin()
+    ];
+    for (const layer of layers) {
+      for (const e of layer) {
+        if (seen.has(e.slug)) continue;
+        seen.add(e.slug);
+        out.push(e);
+      }
+    }
+    this.cache = out;
+    return out;
+  }
+  async find(slugOrId) {
+    const all = await this.list();
+    return all.find((e) => e.slug === slugOrId) ?? all.find((e) => e.id === slugOrId);
+  }
+  async search(query, opts = {}) {
+    let pool = await this.list();
+    if (opts.category) pool = pool.filter((e) => e.category === opts.category);
+    const q = query.trim().toLowerCase();
+    let results;
+    if (!q) {
+      results = pool;
+    } else {
+      const tokens = q.split(/\s+/).filter(Boolean);
+      results = pool.map((e) => ({ e, score: scorePrompt(e, tokens) })).filter((r) => r.score > 0).sort((a, b) => b.score - a.score).map((r) => r.e);
+    }
+    return typeof opts.limit === "number" ? results.slice(0, opts.limit) : results;
+  }
+  async categories() {
+    const all = await this.list();
+    const counts = /* @__PURE__ */ new Map();
+    for (const e of all) counts.set(e.category, (counts.get(e.category) ?? 0) + 1);
+    return [...counts.entries()].map(([id, count]) => ({
+      id,
+      label: isBuiltinCategory(id) ? PROMPT_CATEGORY_LABELS[id] : id,
+      count
+    })).sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+  }
+  async save(entry, opts = {}) {
+    const store = opts.scope === "project" ? this.projectStore : this.userStore;
+    if (!store)
+      throw new Error(`Prompt ${opts.scope ?? "user"} layer is not writable (no directory).`);
+    const normalized = entry.source === "builtin" ? {
+      ...entry,
+      source: opts.scope === "project" ? "project" : "user",
+      forkedFrom: entry.forkedFrom ?? entry.slug
+    } : entry;
+    await store.save(normalized);
+    this.invalidateCache();
+  }
+  async delete(slugOrId) {
+    const entry = await this.find(slugOrId);
+    if (!entry) return false;
+    if (entry.source === "builtin") return false;
+    const store = entry.source === "project" ? this.projectStore : this.userStore;
+    if (!store) return false;
+    const ok = await store.delete(entry.id);
+    if (ok) this.invalidateCache();
+    return ok;
+  }
+  async setFavorite(slugOrId, favorite) {
+    const entry = await this.find(slugOrId);
+    if (!entry) return void 0;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (entry.source === "builtin") {
+      if (!this.userStore) return void 0;
+      const copy = {
+        ...entry,
+        favorite,
+        source: "user",
+        forkedFrom: entry.slug,
+        updatedAt: now
+      };
+      await this.userStore.save(copy);
+      this.invalidateCache();
+      return copy;
+    }
+    const updated = { ...entry, favorite, updatedAt: now };
+    const store = entry.source === "project" ? this.projectStore : this.userStore;
+    if (!store) return void 0;
+    await store.save(updated);
+    this.invalidateCache();
+    return updated;
+  }
+  invalidateCache() {
+    this.cache = void 0;
+    this.builtinCache = void 0;
+  }
+  async readBuiltin() {
+    if (this.builtinCache) return this.builtinCache;
+    const dir = this.builtinDir;
+    if (!dir) {
+      this.builtinCache = [];
+      return [];
+    }
+    const out = [];
+    const files = await walkJson(dir);
+    for (const file of files) {
+      try {
+        const parsed = JSON.parse(await fs.readFile(file, "utf8"));
+        const migrated = migratePromptEntry(parsed);
+        if (migrated) out.push({ ...migrated, source: "builtin" });
+      } catch {
+      }
+    }
+    this.builtinCache = out;
+    return out;
+  }
+};
+async function walkJson(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      out.push(...await walkJson(full));
+    } else if (e.name.endsWith(".json") && e.name !== "index.json" && e.name !== "schema.json") {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function scorePrompt(e, tokens) {
+  const title = e.title.toLowerCase();
+  const slug = e.slug.toLowerCase();
+  const desc = e.description.toLowerCase();
+  const cat = e.category.toLowerCase();
+  const tags = e.tags.map((t) => t.toLowerCase());
+  const content = e.content.toLowerCase();
+  let score = 0;
+  for (const tok of tokens) {
+    let hit = 0;
+    if (title.includes(tok)) hit += 5;
+    if (slug.includes(tok)) hit += 4;
+    if (tags.some((t) => t.includes(tok))) hit += 3;
+    if (desc.includes(tok)) hit += 2;
+    if (cat.includes(tok)) hit += 2;
+    if (content.includes(tok)) hit += 1;
+    if (hit === 0 && tok.length >= 3) {
+      if (isSubsequence(tok, title)) hit += 2;
+      else if (isSubsequence(tok, slug)) hit += 2;
+      else if (tags.some((t) => isSubsequence(tok, t))) hit += 1;
+    }
+    if (hit === 0) return 0;
+    score += hit;
+  }
+  if (e.favorite) score += 1;
+  return score;
+}
+function isSubsequence(needle, hay) {
+  let i = 0;
+  for (let j = 0; j < hay.length && i < needle.length; j++) {
+    if (hay[j] === needle[i]) i++;
+  }
+  return i === needle.length;
+}
+function renderPrompt(entry, values = {}) {
+  const declared = new Map((entry.variables ?? []).map((v) => [v.name, v]));
+  const missing = [];
+  const invalid = [];
+  const text = entry.content.replace(/\{\{\s*([\w.-]+)\s*\}\}/g, (whole, rawName) => {
+    const name = rawName.trim();
+    if (Object.hasOwn(values, name) && values[name] !== void 0) {
+      return values[name];
+    }
+    const decl = declared.get(name);
+    if (decl?.default !== void 0) return decl.default;
+    if (decl?.required) missing.push(name);
+    return whole;
+  });
+  for (const v of entry.variables ?? []) {
+    if (v.required && !(v.name in values) && v.default === void 0 && !missing.includes(v.name)) {
+      if (new RegExp(`\\{\\{\\s*${escapeRegExp(v.name)}\\s*\\}\\}`).test(entry.content)) {
+        missing.push(v.name);
+      }
+    }
+    if (v.enum && v.enum.length > 0 && Object.hasOwn(values, v.name) && values[v.name] !== void 0 && values[v.name] !== "" && !v.enum.includes(values[v.name])) {
+      invalid.push(v.name);
+    }
+  }
+  return { text, missing, invalid };
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  DefaultPromptLoader,
+  renderPrompt
+};
+//# sourceMappingURL=chunk-GAZEWQEZ.js.map

package/dist/chunk-GFJOMSHG.js

@@ -0,0 +1,125 @@
+// src/utils/ip-guard.ts
+import * as dns from "node:dns/promises";
+import * as net from "node:net";
+function isPrivateIPv4(addr) {
+  const parts = addr.split(".").map((p) => Number.parseInt(p, 10));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255)) {
+    return true;
+  }
+  const [a, b, c] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isPrivateIPv6(raw) {
+  const lower = raw.toLowerCase();
+  if (lower === "::" || lower === "::1") return true;
+  const groups = expandIPv6(lower);
+  if (!groups) return true;
+  if (groups[0] === 100 && groups[1] === 65435 && groups[2] === 1) return true;
+  if (groups[0] === 0 && groups[1] === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 65535) {
+    const a = (groups[6] ?? 0) >> 8;
+    const b = (groups[6] ?? 0) & 255;
+    const c = (groups[7] ?? 0) >> 8;
+    const d = (groups[7] ?? 0) & 255;
+    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+  }
+  const embedded = embeddedIPv4(groups);
+  if (embedded) return isPrivateIPv4(embedded);
+  const high = groups[0] ?? 0;
+  if ((high & 65024) === 64512) return true;
+  if ((high & 65472) === 65152) return true;
+  if ((high & 65280) === 65280) return true;
+  return false;
+}
+function quad(hi, lo) {
+  return `${(hi ?? 0) >> 8}.${(hi ?? 0) & 255}.${(lo ?? 0) >> 8}.${(lo ?? 0) & 255}`;
+}
+function embeddedIPv4(groups) {
+  const g = (i) => groups[i] ?? 0;
+  if (g(0) === 100 && g(1) === 65435) {
+    if (g(2) === 0 && g(3) === 0 && g(4) === 0 && g(5) === 0) {
+      return quad(g(6), g(7));
+    }
+  }
+  if (g(0) === 8194) return quad(g(1), g(2));
+  if (g(0) === 8193 && g(1) === 0) {
+    return quad(~g(6) & 65535, ~g(7) & 65535);
+  }
+  if ((g(4) === 0 || g(4) === 512) && g(5) === 24318) {
+    return quad(g(6), g(7));
+  }
+  const highZero = g(0) === 0 && g(1) === 0 && g(2) === 0 && g(3) === 0;
+  if (highZero && g(4) === 65535 && g(5) === 0) return quad(g(6), g(7));
+  if (highZero && g(4) === 0 && g(5) === 0) return quad(g(6), g(7));
+  return void 0;
+}
+function expandIPv6(addr) {
+  const parts = addr.split("::");
+  if (parts.length > 2) return null;
+  const parseGroups = (s) => {
+    if (s === "") return [];
+    const out = [];
+    for (const g of s.split(":")) {
+      if (g.length === 0 || g.length > 4) return null;
+      const n = Number.parseInt(g, 16);
+      if (Number.isNaN(n) || n < 0 || n > 65535) return null;
+      out.push(n);
+    }
+    return out;
+  };
+  if (parts.length === 1) {
+    const groups = parseGroups(parts[0] ?? "");
+    if (groups?.length !== 8) return null;
+    return groups;
+  }
+  const head = parseGroups(parts[0] ?? "");
+  const tail = parseGroups(parts[1] ?? "");
+  if (!head || !tail) return null;
+  const fill = 8 - head.length - tail.length;
+  if (fill < 0) return null;
+  return [...head, ...new Array(fill).fill(0), ...tail];
+}
+async function assertNotPrivateHost(hostname) {
+  const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  if (host === "localhost" || host.endsWith(".localhost")) {
+    throw new Error("fetch: blocked localhost target");
+  }
+  const ipVersion = net.isIP(host);
+  if (ipVersion === 4) {
+    if (isPrivateIPv4(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else if (ipVersion === 6) {
+    if (isPrivateIPv6(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else {
+    try {
+      const records = await dns.lookup(host, { all: true });
+      for (const r of records) {
+        const bad = r.family === 4 ? isPrivateIPv4(r.address) : isPrivateIPv6(r.address);
+        if (bad) {
+          throw new Error(`fetch: resolved to private address ${r.address}`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("fetch:")) throw err;
+    }
+  }
+}
+
+export {
+  isPrivateIPv4,
+  isPrivateIPv6,
+  expandIPv6,
+  assertNotPrivateHost
+};
+//# sourceMappingURL=chunk-GFJOMSHG.js.map

package/dist/chunk-GFXZTHNI.js

@@ -0,0 +1,158 @@
+import {
+  slugify
+} from "./chunk-TYW2GI5I.js";
+import {
+  ulid
+} from "./chunk-4XV6IR37.js";
+import {
+  atomicWrite,
+  ensureDir
+} from "./chunk-7ZHZE5EO.js";
+
+// src/storage/prompt-store.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var SCHEMA_VERSION = 2;
+function promptChecksum(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function migratePromptEntry(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r["id"] !== "string" || typeof r["title"] !== "string") return null;
+  const title = r["title"];
+  const content = typeof r["content"] === "string" ? r["content"] : "";
+  const now = typeof r["createdAt"] === "string" ? r["createdAt"] : (/* @__PURE__ */ new Date(0)).toISOString();
+  const tags = Array.isArray(r["tags"]) ? r["tags"].filter((t) => typeof t === "string") : [];
+  return {
+    id: r["id"],
+    slug: typeof r["slug"] === "string" && r["slug"].length > 0 ? r["slug"] : slugify(title),
+    title,
+    description: typeof r["description"] === "string" ? r["description"] : "",
+    content,
+    category: typeof r["category"] === "string" && r["category"].length > 0 ? r["category"] : "uncategorized",
+    tags,
+    source: isPromptSource(r["source"]) ? r["source"] : "user",
+    favorite: r["favorite"] === true,
+    variables: normalizeVariables(r["variables"]),
+    author: typeof r["author"] === "string" ? r["author"] : void 0,
+    version: typeof r["version"] === "string" ? r["version"] : void 0,
+    license: typeof r["license"] === "string" ? r["license"] : void 0,
+    checksum: typeof r["checksum"] === "string" ? r["checksum"] : void 0,
+    forkedFrom: typeof r["forkedFrom"] === "string" ? r["forkedFrom"] : void 0,
+    createdAt: now,
+    updatedAt: typeof r["updatedAt"] === "string" ? r["updatedAt"] : now
+  };
+}
+function isPromptSource(v) {
+  return v === "builtin" || v === "user" || v === "project" || v === "synced";
+}
+function normalizeVariables(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = [];
+  for (const item of v) {
+    if (item && typeof item === "object" && typeof item["name"] === "string") {
+      const o = item;
+      const enumVals = Array.isArray(o["enum"]) && o["enum"].every((x) => typeof x === "string") ? o["enum"] : void 0;
+      out.push({
+        name: o["name"],
+        description: typeof o["description"] === "string" ? o["description"] : void 0,
+        default: typeof o["default"] === "string" ? o["default"] : void 0,
+        required: o["required"] === true ? true : void 0,
+        enum: enumVals && enumVals.length > 0 ? enumVals : void 0,
+        multiline: o["multiline"] === true ? true : void 0
+      });
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+var DefaultPromptStore = class {
+  dir;
+  constructor(pathsOrDir) {
+    this.dir = typeof pathsOrDir === "string" ? pathsOrDir : pathsOrDir.globalPrompts;
+  }
+  async list() {
+    await ensureDir(this.dir);
+    const entries = [];
+    try {
+      const files = await fs.readdir(this.dir);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const raw = JSON.parse(
+            await fs.readFile(path.join(this.dir, file), "utf8")
+          );
+          const migrated = migratePromptEntry(raw.entry);
+          if (migrated) entries.push(migrated);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return entries.sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+  }
+  async get(id) {
+    const file = path.join(this.dir, `${id}.json`);
+    try {
+      const raw = JSON.parse(await fs.readFile(file, "utf8"));
+      return migratePromptEntry(raw.entry);
+    } catch {
+      return null;
+    }
+  }
+  async save(entry) {
+    await ensureDir(this.dir);
+    const file = path.join(this.dir, `${entry.id}.json`);
+    const raw = { version: SCHEMA_VERSION, entry };
+    await atomicWrite(file, JSON.stringify(raw, null, 2));
+  }
+  async delete(id) {
+    const file = path.join(this.dir, `${id}.json`);
+    try {
+      await fs.unlink(file);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async find(query) {
+    const all = await this.list();
+    const lower = query.toLowerCase();
+    return all.filter(
+      (e) => e.title.toLowerCase().includes(lower) || e.description.toLowerCase().includes(lower) || e.content.toLowerCase().includes(lower) || e.category.toLowerCase().includes(lower) || e.tags.some((t) => t.toLowerCase().includes(lower))
+    );
+  }
+  /** Create a new v2 entry and return it. Does NOT persist — call save() afterwards. */
+  createNew(title, content, tags = [], extra = {}) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: ulid(),
+      slug: extra.slug && extra.slug.length > 0 ? extra.slug : slugify(title),
+      title,
+      description: extra.description ?? "",
+      content,
+      category: extra.category ?? "uncategorized",
+      tags,
+      source: extra.source ?? "user",
+      favorite: extra.favorite ?? false,
+      variables: extra.variables,
+      author: extra.author,
+      version: extra.version,
+      license: extra.license,
+      checksum: extra.checksum,
+      forkedFrom: extra.forkedFrom,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+};
+
+export {
+  promptChecksum,
+  migratePromptEntry,
+  DefaultPromptStore
+};
+//# sourceMappingURL=chunk-GFXZTHNI.js.map