@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-PFZO3C6H.js

@@ -0,0 +1,14 @@
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    const err = new Error(label ? `Expected ${label} to be defined` : "Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
+  }
+  return value;
+}
+
+export {
+  expectDefined
+};
+//# sourceMappingURL=chunk-PFZO3C6H.js.map

package/dist/chunk-PGRVXIMY.js

@@ -0,0 +1,158 @@
+import {
+  slugify
+} from "./chunk-J2WRWR37.js";
+import {
+  ulid
+} from "./chunk-HI3JGZR2.js";
+import {
+  atomicWrite,
+  ensureDir
+} from "./chunk-OSGLYW5J.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) => (Date.parse(b.updatedAt) || 0) - (Date.parse(a.updatedAt) || 0)
+    );
+  }
+  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-PGRVXIMY.js.map

package/dist/chunk-PHH7LD45.js

@@ -0,0 +1,113 @@
+// src/notifications/notifier-impl.ts
+function emptyCounters() {
+  return { attempted: 0, delivered: 0, failed: 0, suppressed: 0 };
+}
+var NotifierImpl = class _NotifierImpl {
+  #channels = /* @__PURE__ */ new Map();
+  #counters = /* @__PURE__ */ new Map();
+  /** Soft cap for #counters — prevents unbounded growth if channels are
+   *  repeatedly registered with distinct names. */
+  static #MAX_COUNTERS = 100;
+  // -----------------------------------------------------------------------
+  // Lifecycle
+  // -----------------------------------------------------------------------
+  notify(channels, message) {
+    const names = typeof channels === "string" ? [channels] : channels;
+    if (names.length === 0) return Promise.resolve([]);
+    const results = [];
+    for (const name of names) {
+      const channel = this.#channels.get(name);
+      if (!channel) continue;
+      const counters = this.#counters.get(name) ?? emptyCounters();
+      counters.attempted += 1;
+      this.#counters.set(name, counters);
+      results.push(
+        channel.deliver(message).then(
+          (result) => {
+            if (result.ok) {
+              counters.delivered += 1;
+            } else {
+              counters.failed += 1;
+            }
+            return result;
+          },
+          (err) => {
+            counters.failed += 1;
+            const error = err instanceof Error ? err.message : "unknown rejection";
+            return {
+              ok: false,
+              channel: name,
+              error: `threw: ${error}`,
+              deliveredAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+          }
+        )
+      );
+    }
+    return Promise.all(results);
+  }
+  registerChannel(channel) {
+    this.#channels.set(channel.name, channel);
+    if (!this.#counters.has(channel.name)) {
+      if (this.#counters.size >= _NotifierImpl.#MAX_COUNTERS) {
+        const oldest = this.#counters.keys().next();
+        if (!oldest.done && oldest.value !== void 0) {
+          this.#counters.delete(oldest.value);
+        }
+      }
+      this.#counters.set(channel.name, emptyCounters());
+    }
+  }
+  unregisterChannel(name) {
+    this.#channels.delete(name);
+  }
+  async channels() {
+    const entries = Array.from(this.#channels.entries());
+    const results = await Promise.allSettled(
+      entries.map(async ([name, channel]) => {
+        try {
+          const ping = await channel.ping();
+          return { name, type: channel.type, ok: ping.ok, error: ping.error };
+        } catch {
+          return { name, type: channel.type, ok: false, error: "ping threw" };
+        }
+      })
+    );
+    return results.map(
+      (r) => r.status === "fulfilled" ? r.value : { name: "unknown", type: "unknown", ok: false, error: "unhandled ping rejection" }
+    );
+  }
+  counters() {
+    let attempted = 0;
+    let delivered = 0;
+    let failed = 0;
+    let suppressed = 0;
+    for (const c of this.#counters.values()) {
+      attempted += c.attempted;
+      delivered += c.delivered;
+      failed += c.failed;
+      suppressed += c.suppressed;
+    }
+    return { attempted, delivered, failed, suppressed };
+  }
+  /**
+   * Return per-channel counters for detailed diagnostics.
+   * Not part of the `Notifier` interface — available on the concrete class.
+   */
+  perChannelCounters() {
+    const result = {};
+    for (const [name, c] of this.#counters) {
+      result[name] = {
+        attempted: c.attempted,
+        delivered: c.delivered,
+        failed: c.failed
+      };
+    }
+    return result;
+  }
+};
+
+export {
+  NotifierImpl
+};
+//# sourceMappingURL=chunk-PHH7LD45.js.map

package/dist/chunk-PISBFBJN.js

@@ -0,0 +1,109 @@
+import {
+  atomicWrite,
+  ensureDir
+} from "./chunk-OSGLYW5J.js";
+import {
+  diffRegistry,
+  validateRegistryManifest
+} from "./chunk-IYFBFX34.js";
+import {
+  FetchError,
+  ParseError
+} from "./chunk-25LSLC3G.js";
+
+// src/prompts/prompt-installer.ts
+var defaultFetcher = async (url) => {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new FetchError({
+      message: `registry fetch failed: ${res.status} ${res.statusText}`,
+      status: res.status,
+      context: { op: "fetchManifest" }
+    });
+  }
+  return res.json();
+};
+var PromptInstaller = class {
+  fetcher;
+  constructor(opts = {}) {
+    this.fetcher = opts.fetcher ?? defaultFetcher;
+  }
+  /**
+   * Fetch + validate a manifest and report what a sync WOULD change. Read-only.
+   * @param manifestUrl URL to the registry's `registry.json`.
+   * @param local       The prompts the caller already has (slug + checksum).
+   */
+  async pull(manifestUrl, local) {
+    const raw = await this.fetcher(manifestUrl);
+    const validated = validateRegistryManifest(raw);
+    if (!validated.ok) {
+      throw new ParseError({
+        message: `Invalid prompt registry manifest:
+  - ${validated.errors.join("\n  - ")}`,
+        source: "prompt-registry-manifest"
+      });
+    }
+    const diff = diffRegistry(local, validated.manifest);
+    return { manifest: validated.manifest, diff, dryRun: true };
+  }
+  /**
+   * EXTENSION POINT (not yet wired): download the prompt bodies for the given
+   * registry refs and write them into the user layer as `source:'synced'`,
+   * recording each in the installed-prompts manifest. Intentionally unimplemented
+   * — pulling real content over the network is gated behind a future change so
+   * the format/diff path can ship and be reviewed first.
+   */
+  async install() {
+    throw new Error(
+      "Prompt sync is not implemented yet. `pull()` reports the diff; installing remote prompt bodies will land in a follow-up."
+    );
+  }
+};
+
+// src/prompts/prompt-manifest-store.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var PromptManifestStore = class {
+  constructor(manifestPath) {
+    this.manifestPath = manifestPath;
+  }
+  manifestPath;
+  async load() {
+    try {
+      const raw = JSON.parse(await fs.readFile(this.manifestPath, "utf8"));
+      if (raw && typeof raw === "object" && Array.isArray(raw.entries)) {
+        return { version: 1, entries: raw.entries };
+      }
+    } catch {
+    }
+    return { version: 1, entries: [] };
+  }
+  async save(data) {
+    await ensureDir(path.dirname(this.manifestPath));
+    await atomicWrite(this.manifestPath, JSON.stringify(data, null, 2));
+  }
+  /** Upsert one entry keyed by slug. */
+  async record(entry) {
+    const data = await this.load();
+    const idx = data.entries.findIndex((e) => e.slug === entry.slug);
+    if (idx === -1) data.entries.push(entry);
+    else data.entries[idx] = entry;
+    await this.save(data);
+  }
+  async remove(slug) {
+    const data = await this.load();
+    const next = data.entries.filter((e) => e.slug !== slug);
+    if (next.length === data.entries.length) return false;
+    await this.save({ version: 1, entries: next });
+    return true;
+  }
+  async list() {
+    return (await this.load()).entries;
+  }
+};
+
+export {
+  PromptInstaller,
+  PromptManifestStore
+};
+//# sourceMappingURL=chunk-PISBFBJN.js.map

package/dist/chunk-POOOIWE5.js

@@ -0,0 +1,9 @@
+// src/utils/socket-path.ts
+import { assertUnixSocketPathWithinLimit, checkUnixSocketPath, unixSocketPathLimit } from "@wrongstack/persistence";
+
+export {
+  assertUnixSocketPathWithinLimit,
+  checkUnixSocketPath,
+  unixSocketPathLimit
+};
+//# sourceMappingURL=chunk-POOOIWE5.js.map