@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-52RTVH4M.js

@@ -0,0 +1,361 @@
+import {
+  SESSION_CATALOG_MAX_FRAME_CHARS,
+  SESSION_CATALOG_PROTOCOL_VERSION,
+  encodeSessionCatalogMessage,
+  sessionCatalogProjectServerEndpoint,
+  sessionCatalogProjectServerMetadataPath
+} from "./chunk-E6I5RXVK.js";
+
+// src/session-catalog/client.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var CONNECT_TIMEOUT_MS = 750;
+var START_TIMEOUT_MS = 1e4;
+var CALL_TIMEOUT_MS = 3e4;
+var MAX_PENDING_REQUESTS = 1024;
+var MAX_EVENT_LISTENERS = 64;
+function locateServer(moduleUrl, exists) {
+  for (const candidate of [
+    "./project-server.js",
+    "../session-catalog/project-server.js",
+    "./session-catalog/project-server.js",
+    "../../dist/session-catalog/project-server.js"
+  ]) {
+    try {
+      const url = new URL(candidate, moduleUrl);
+      if (url.protocol === "file:" && exists(fileURLToPath(url))) return url;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveSessionCatalogDaemonAvailability(moduleUrl = import.meta.url, exists = fs.existsSync) {
+  if (process.env["WRONGSTACK_SESSION_CATALOG_INLINE"] || process.env["WRONGSTACK_SESSION_CATALOG_SERVER"] === "0")
+    return { kind: "inline-requested" };
+  const url = locateServer(moduleUrl, exists);
+  return url ? { kind: "available", url } : { kind: "missing-build" };
+}
+function resolveSessionCatalogProjectServerUrl(moduleUrl = import.meta.url, exists = fs.existsSync) {
+  const availability = resolveSessionCatalogDaemonAvailability(moduleUrl, exists);
+  return availability.kind === "available" ? availability.url : null;
+}
+function normalize(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var SessionCatalogProjectClient = class {
+  constructor(options) {
+    this.options = options;
+    this.endpoint = sessionCatalogProjectServerEndpoint(options.projectDir);
+  }
+  options;
+  endpoint;
+  socket = null;
+  info = null;
+  buffer = "";
+  connecting = null;
+  connectResolve = null;
+  connectReject = null;
+  authToken;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Set();
+  reconnectTimer;
+  explicitlyClosed = false;
+  async call(op, args, options = {}) {
+    await this.ensureConnected(true);
+    return this.request({ type: "request", op, args }, options.timeoutMs ?? CALL_TIMEOUT_MS);
+  }
+  /**
+   * Call an already-running project daemon without starting one.
+   *
+   * Cross-project discovery must use this path: observing another project is
+   * never sufficient authority to wake that project's IPC owner.
+   */
+  async callExisting(op, args, options = {}) {
+    await this.ensureConnected(false);
+    return this.request({ type: "request", op, args }, options.timeoutMs ?? CALL_TIMEOUT_MS);
+  }
+  ping() {
+    return this.call("ping", {}, { timeoutMs: 3e3 });
+  }
+  async subscribe(listener) {
+    if (!this.eventListeners.has(listener) && this.eventListeners.size >= MAX_EVENT_LISTENERS) {
+      throw new Error(`Session Catalog listener limit reached (${MAX_EVENT_LISTENERS})`);
+    }
+    this.explicitlyClosed = false;
+    this.eventListeners.add(listener);
+    try {
+      await this.call("subscribe", {});
+    } catch (error) {
+      this.eventListeners.delete(listener);
+      throw error;
+    }
+    return async () => {
+      this.eventListeners.delete(listener);
+      if (this.eventListeners.size === 0)
+        await this.callExisting("unsubscribe", {}).catch(() => void 0);
+    };
+  }
+  async shutdown(reason) {
+    try {
+      await this.ensureConnected(false);
+    } catch {
+      return { stopped: false };
+    }
+    const result = await this.request({ type: "shutdown", ...reason !== void 0 ? { reason } : {} }, 5e3).catch(
+      () => ({ stopped: false })
+    );
+    if (result.stopped) {
+      const metadataPath = sessionCatalogProjectServerMetadataPath(this.options.projectDir);
+      const deadline = Date.now() + 5e3;
+      while (fs.existsSync(metadataPath) && Date.now() < deadline) await delay(20);
+      if (result.pid && result.pid !== process.pid) {
+        while (Date.now() < deadline) {
+          try {
+            process.kill(result.pid, 0);
+            await delay(20);
+          } catch {
+            break;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  async close() {
+    this.explicitlyClosed = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = void 0;
+    const socket = this.socket;
+    this.socket = null;
+    this.info = null;
+    if (socket && !socket.destroyed)
+      await new Promise((resolve2) => {
+        socket.once("close", resolve2);
+        socket.end();
+      });
+  }
+  async ensureConnected(spawnIfMissing) {
+    if (this.socket && !this.socket.destroyed && this.info) return;
+    if (this.connecting) return this.connecting;
+    this.connecting = this.connectWithElection(spawnIfMissing).finally(() => {
+      this.connecting = null;
+    });
+    return this.connecting;
+  }
+  async connectWithElection(spawnIfMissing) {
+    const deadline = Date.now() + (spawnIfMissing ? START_TIMEOUT_MS : CONNECT_TIMEOUT_MS);
+    let spawned = false;
+    let lastError = new Error("Session Catalog project server unavailable");
+    while (Date.now() < deadline) {
+      try {
+        await this.connectOnce();
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+      if (!spawnIfMissing) break;
+      if (!spawned) {
+        this.spawnDetached();
+        spawned = true;
+      }
+      await delay(75);
+    }
+    throw lastError;
+  }
+  connectOnce() {
+    this.socket?.destroy();
+    this.socket = null;
+    this.info = null;
+    this.authToken = void 0;
+    this.buffer = "";
+    return new Promise((resolve2, reject) => {
+      const socket = net.createConnection(this.endpoint);
+      this.socket = socket;
+      socket.setEncoding("utf8");
+      const timer = setTimeout(() => {
+        reject(new Error("Session Catalog handshake timed out"));
+        socket.destroy();
+      }, CONNECT_TIMEOUT_MS);
+      timer.unref?.();
+      this.connectResolve = () => {
+        clearTimeout(timer);
+        this.connectResolve = null;
+        this.connectReject = null;
+        resolve2();
+      };
+      this.connectReject = (error) => {
+        clearTimeout(timer);
+        this.connectResolve = null;
+        this.connectReject = null;
+        reject(error);
+      };
+      socket.on("data", (chunk) => this.onData(socket, chunk));
+      socket.on("error", (error) => {
+        if (!this.info) this.connectReject?.(error);
+      });
+      socket.on("close", () => this.onClose(socket));
+    });
+  }
+  currentAuthToken() {
+    if (this.authToken === void 0) {
+      try {
+        const parsed = JSON.parse(
+          fs.readFileSync(sessionCatalogProjectServerMetadataPath(this.options.projectDir), "utf8")
+        );
+        if (typeof parsed.authToken === "string" && parsed.authToken)
+          this.authToken = parsed.authToken;
+      } catch {
+      }
+    }
+    return this.authToken;
+  }
+  request(message, timeoutMs) {
+    const socket = this.socket;
+    if (!socket || socket.destroyed)
+      return Promise.reject(new Error("Session Catalog connection is unavailable"));
+    const id = this.nextId++;
+    if (this.pending.size >= MAX_PENDING_REQUESTS) {
+      return Promise.reject(
+        new Error(`Session Catalog pending request limit reached (${MAX_PENDING_REQUESTS})`)
+      );
+    }
+    const encoded = encodeSessionCatalogMessage({
+      ...message,
+      id,
+      authToken: this.currentAuthToken()
+    });
+    if (encoded.length > SESSION_CATALOG_MAX_FRAME_CHARS)
+      return Promise.reject(new Error("Session Catalog request exceeded frame limit"));
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        this.pending.delete(id);
+        pending.reject(
+          new Error(
+            `Session Catalog ${message.type === "request" ? message.op : message.type} timed out`
+          )
+        );
+      }, timeoutMs);
+      timer.unref?.();
+      this.pending.set(id, { resolve: resolve2, reject, timer });
+      socket.write(encoded);
+    });
+  }
+  onData(socket, chunk) {
+    if (socket !== this.socket) return;
+    this.buffer += chunk;
+    if (this.buffer.length > SESSION_CATALOG_MAX_FRAME_CHARS) {
+      socket.destroy(new Error("Session Catalog response exceeded frame limit"));
+      return;
+    }
+    while (true) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0) return;
+      const line = this.buffer.slice(0, newline);
+      this.buffer = this.buffer.slice(newline + 1);
+      if (!line) continue;
+      try {
+        this.onMessage(JSON.parse(line));
+      } catch {
+        socket.destroy(new Error("Invalid Session Catalog response"));
+        return;
+      }
+    }
+  }
+  onMessage(message) {
+    if (message.type === "hello") {
+      if (message.protocolVersion !== SESSION_CATALOG_PROTOCOL_VERSION) {
+        this.connectReject?.(
+          new Error(
+            `Session Catalog protocol mismatch: client=${SESSION_CATALOG_PROTOCOL_VERSION}, server=${message.protocolVersion}`
+          )
+        );
+        this.socket?.destroy();
+        return;
+      }
+      if (normalize(message.projectDir) !== normalize(this.options.projectDir) || normalize(message.projectRoot) !== normalize(this.options.projectRoot)) {
+        this.connectReject?.(new Error("Session Catalog project identity mismatch"));
+        this.socket?.destroy();
+        return;
+      }
+      this.info = message;
+      this.connectResolve?.();
+      return;
+    }
+    if (message.type === "event") {
+      for (const listener of this.eventListeners) {
+        try {
+          listener(message.event);
+        } catch {
+        }
+      }
+      return;
+    }
+    const pending = this.pending.get(message.id);
+    if (!pending) return;
+    this.pending.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.ok) pending.resolve(message.result);
+    else {
+      const error = new Error(message.error);
+      if (message.errorName) error.name = message.errorName;
+      pending.reject(error);
+    }
+  }
+  onClose(socket) {
+    if (socket !== this.socket) return;
+    this.socket = null;
+    this.info = null;
+    this.authToken = void 0;
+    const error = new Error("Session Catalog connection closed");
+    this.connectReject?.(error);
+    this.connectResolve = null;
+    this.connectReject = null;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+    this.scheduleSubscriptionReconnect();
+  }
+  scheduleSubscriptionReconnect() {
+    if (this.explicitlyClosed || this.eventListeners.size === 0 || this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      void this.call("subscribe", {}).catch(() => this.scheduleSubscriptionReconnect());
+    }, 250);
+    this.reconnectTimer.unref?.();
+  }
+  spawnDetached() {
+    const url = resolveSessionCatalogProjectServerUrl();
+    if (!url) throw new Error("Built Session Catalog project server is unavailable");
+    const child = spawn(
+      process.execPath,
+      [
+        fileURLToPath(url),
+        "--project-dir",
+        this.options.projectDir,
+        "--project-root",
+        this.options.projectRoot
+      ],
+      { detached: true, stdio: "ignore", windowsHide: true, env: process.env }
+    );
+    child.unref();
+  }
+};
+
+export {
+  resolveSessionCatalogDaemonAvailability,
+  resolveSessionCatalogProjectServerUrl,
+  SessionCatalogProjectClient
+};
+//# sourceMappingURL=chunk-52RTVH4M.js.map

package/dist/chunk-57GEWK5X.js

@@ -0,0 +1,26 @@
+// src/types/memory.ts
+var MEMORY_TYPE_LABELS = {
+  fact: "Fact",
+  decision: "Decision",
+  convention: "Convention",
+  preference: "Preference",
+  reference: "Reference",
+  anti_pattern: "Anti-pattern"
+};
+function defineMemoryCapability(id) {
+  return Object.freeze({
+    id,
+    /** Identity function that makes the brand a real runtime value so
+     *  `defineMemoryCapability<A>('x')` and `defineMemoryCapability<B>('x')`
+     *  produce structurally distinct objects. Capability lookup is still
+     *  keyed by `id` only — the brand prevents accidental cross-type casts
+     *  at the type level. */
+    __memoryCapabilityType: (v) => v
+  });
+}
+
+export {
+  MEMORY_TYPE_LABELS,
+  defineMemoryCapability
+};
+//# sourceMappingURL=chunk-57GEWK5X.js.map