@wrongstack/cli 1.0.17 → 1.0.24

package/dist/typesafe-topic-replay-4W73BOLV.js

@@ -0,0 +1,218 @@
+import {
+  createProviderForId
+} from "./chunk-BBHWW6LR.js";
+
+// src/subcommands/handlers/typesafe-topic-replay.ts
+import { readdir, readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { gunzip } from "node:zlib";
+import { TopicShiftAdvisor } from "@wrongstack/core/execution";
+import { resolveTypeSafeAccount } from "@wrongstack/core/typesafe";
+import { color } from "@wrongstack/core/utils";
+var gunzipAsync = promisify(gunzip);
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((b) => b?.type === "text").map((b) => b.text).join("\n");
+}
+async function sessionFiles(root) {
+  const out = [];
+  let days;
+  try {
+    days = await readdir(root);
+  } catch {
+    return out;
+  }
+  for (const day of days.sort()) {
+    let entries;
+    try {
+      entries = await readdir(path.join(root, day));
+    } catch {
+      continue;
+    }
+    for (const name of entries.sort()) {
+      if (/^sess_[^.]+\.jsonl(\.gz)?$/.test(name)) out.push(path.join(root, day, name));
+    }
+  }
+  return out;
+}
+async function promptPoints(file) {
+  const buf = await readFile(file);
+  const raw = file.endsWith(".gz") ? (await gunzipAsync(buf)).toString("utf8") : buf.toString("utf8");
+  const messages = [];
+  const points = [];
+  let contextTokens;
+  let previousPrompt = "";
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e["type"] === "llm_request" && typeof e["estimatedInputTokens"] === "number") {
+      contextTokens = e["estimatedInputTokens"];
+    } else if (e["type"] === "user_input") {
+      const prompt = textOf(e["content"]).trim();
+      if (prompt) {
+        points.push({
+          session: path.basename(file).replace(/\.jsonl(\.gz)?$/, ""),
+          prompt,
+          previousPrompt,
+          messages: [...messages],
+          contextTokens
+        });
+        previousPrompt = prompt;
+      }
+    } else if (e["type"] === "message_appended") {
+      const m = e["message"];
+      if (m && (m.role === "user" || m.role === "assistant")) {
+        const text = textOf(m.content).trim();
+        if (text) messages.push({ role: m.role, content: text });
+      }
+    }
+  }
+  return points;
+}
+async function replayTopicShift(deps, write) {
+  const flags = deps.flags ?? {};
+  const json = flags["json"] === true;
+  const account = resolveTypeSafeAccount({ config: deps.config, restGate: null });
+  if (account.status !== "ready") {
+    write(`${color.red("\u2717")} ${account.reason}. Run \`wstack typesafe login\`.`);
+    return 2;
+  }
+  const limit = Math.max(1, Number(flags["limit"]) || 40);
+  const maxContext = Math.max(1, Number(flags["max-context"]) || 2e5);
+  const sessionsRoot = typeof flags["sessions"] === "string" ? path.resolve(flags["sessions"]) : path.join(deps.paths.projectDir, "sessions");
+  const providerId = typeof flags["provider"] === "string" ? flags["provider"] : deps.config.provider;
+  const model = typeof flags["model"] === "string" ? flags["model"] : deps.config.model;
+  const provider = flags["no-llm"] === true ? void 0 : createProviderForId(providerId, deps.config);
+  const judge = { client: account.client, model: account.model, feature: "topicShift" };
+  const reached = [];
+  let scanned = 0;
+  const files = await sessionFiles(sessionsRoot);
+  for (const file of files.reverse()) {
+    if (reached.length >= limit) break;
+    let points;
+    try {
+      points = await promptPoints(file);
+    } catch {
+      continue;
+    }
+    for (const point of points) {
+      if (reached.length >= limit) break;
+      scanned++;
+      let gate = false;
+      let jevNoul;
+      let jevError;
+      const jevAdvisor = new TopicShiftAdvisor({
+        getJudge: () => judge,
+        onDiagnostic: (d) => {
+          if (d.stage === "gate") gate = true;
+          if (d.stage === "system-one") {
+            jevNoul = d.noul;
+            jevError = d.error;
+          }
+        }
+      });
+      await jevAdvisor.advise({
+        prompt: point.prompt,
+        messages: point.messages,
+        contextTokens: point.contextTokens,
+        maxContext
+      });
+      if (!gate) continue;
+      const c = { ...point, jevNoul, jevError };
+      if (provider?.complete) {
+        let failure;
+        const llmAdvisor = new TopicShiftAdvisor({
+          onDiagnostic: (d) => {
+            if (d.stage === "model" && !d.parsed) {
+              failure = d.error ?? (d.text?.trim() ? "unparseable reply" : "empty reply");
+            }
+          }
+        });
+        const advice = await llmAdvisor.advise({
+          prompt: point.prompt,
+          messages: point.messages,
+          provider,
+          model,
+          contextTokens: point.contextTokens,
+          maxContext
+        });
+        if (advice.source === "model") {
+          c.llm = advice.suggestNewContext ? "new" : "same";
+          c.llmConfidence = advice.confidence;
+        } else {
+          c.llmFailure = failure ?? `no model answer (${advice.source})`;
+        }
+      }
+      reached.push(c);
+    }
+  }
+  const bucket = (n) => n === void 0 ? "none" : n >= 0.8 ? "new" : n <= 0.3 ? "same" : "unsure";
+  if (json) {
+    write(
+      JSON.stringify(
+        {
+          sessionsRoot,
+          scanned,
+          llm: provider ? `${providerId}/${model}` : null,
+          cases: reached.map((c) => ({
+            session: c.session,
+            previousPrompt: c.previousPrompt.slice(0, 200),
+            prompt: c.prompt.slice(0, 300),
+            jev: c.jevNoul === void 0 ? null : Number(c.jevNoul.toFixed(3)),
+            jevBucket: bucket(c.jevNoul),
+            jevError: c.jevError,
+            llm: c.llm ?? null,
+            llmConfidence: c.llmConfidence,
+            llmFailure: c.llmFailure
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  const pct = (a, b) => b === 0 ? "\u2014" : `${Math.round(a / b * 100)}%`;
+  const count = (b) => reached.filter((c) => bucket(c.jevNoul) === b).length;
+  write(
+    color.dim(
+      `${scanned} prompt(s) scanned in ${files.length} session file(s); ${reached.length} passed the local gate and reached a classifier`
+    )
+  );
+  write(color.bold("Jev"));
+  write(
+    `  new ${count("new")}  same ${count("same")}  unsure\u2192provider ${count("unsure")}  no answer ${count("none")}`
+  );
+  if (provider) {
+    const answered = reached.filter((c) => c.llm);
+    write(color.bold(`Provider classifier (${providerId}/${model}, production request shape)`));
+    write(
+      `  answered ${answered.length}/${reached.length}  new ${answered.filter((c) => c.llm === "new").length}  same ${answered.filter((c) => c.llm === "same").length}`
+    );
+    const failures = /* @__PURE__ */ new Map();
+    for (const c of reached) {
+      if (c.llmFailure) failures.set(c.llmFailure, (failures.get(c.llmFailure) ?? 0) + 1);
+    }
+    for (const [reason, n] of failures) write(color.amber(`  ${n}\xD7 ${reason.slice(0, 100)}`));
+    const both = reached.filter((c) => c.llm && ["new", "same"].includes(bucket(c.jevNoul)));
+    write(
+      `  agreement where Jev is decisive: ${pct(
+        both.filter((c) => bucket(c.jevNoul) === c.llm).length,
+        both.length
+      )} of ${both.length}`
+    );
+  }
+  write(color.dim(`model ${account.model}`));
+  return 0;
+}
+export {
+  replayTopicShift
+};
+//# sourceMappingURL=typesafe-topic-replay-4W73BOLV.js.map

package/dist/typesafe-triage-replay-FGAW7QM7.js

@@ -0,0 +1,215 @@
+import {
+  createProviderForId
+} from "./chunk-BBHWW6LR.js";
+
+// src/subcommands/handlers/typesafe-triage-replay.ts
+import * as path from "node:path";
+import { resolveTypeSafeAccount } from "@wrongstack/core/typesafe";
+import { color } from "@wrongstack/core/utils";
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
+import {
+  computeValueScore,
+  evaluateMemory,
+  preFilterBatch,
+  probeMemoryValue
+} from "@wrongstack/sage";
+var SYSTEM_ONE_MIN_CONFIDENCE = 0.55;
+var SYSTEM_ONE_MIN_PROBABILITY = 0.5;
+async function loadMemories(dbPath) {
+  const Database = loadRuntimeDatabaseSync();
+  const db = new Database(dbPath, { readOnly: true });
+  try {
+    const rows = db.prepare("SELECT data FROM memories WHERE status IN ('active', 'stale')").all();
+    const out = [];
+    for (const row of rows) {
+      try {
+        out.push(JSON.parse(row.data));
+      } catch {
+      }
+    }
+    return out;
+  } finally {
+    db.close();
+  }
+}
+async function actionFor(memory, score) {
+  const vs = computeValueScore(memory);
+  const result = await evaluateMemory(memory, vs, async () => `${score} | calibration`);
+  return result.action === "keep_llm_override" ? "keep" : result.action;
+}
+async function replayMemoryTriage(deps, write) {
+  const flags = deps.flags ?? {};
+  const account = resolveTypeSafeAccount({ config: deps.config, restGate: null });
+  if (account.status !== "ready") {
+    write(`${color.red("\u2717")} ${account.reason}. Run \`wstack typesafe login\`.`);
+    return 2;
+  }
+  const limit = Math.max(1, Number(flags["limit"]) || 40);
+  const useLlm = flags["no-llm"] !== true;
+  const storageDir = deps.config.Sage?.storage?.directory;
+  const dbPath = path.resolve(
+    deps.projectRoot,
+    storageDir && typeof storageDir === "string" ? storageDir : path.join(".wrongstack", "memories"),
+    "sage.db"
+  );
+  let memories;
+  try {
+    memories = await loadMemories(dbPath);
+  } catch (err) {
+    write(`${color.red("\u2717")} cannot open ${dbPath}: ${err.message}`);
+    return 2;
+  }
+  const { uncertain } = preFilterBatch(memories);
+  const gray = uncertain.map((memory) => ({ memory, vs: computeValueScore(memory) })).filter((x) => x.vs.band === "gray");
+  const step = Math.max(1, gray.length / limit);
+  const cases = [];
+  for (let i = 0; i < gray.length && cases.length < limit; i += step) {
+    const pick = gray[Math.floor(i)];
+    if (pick) cases.push({ memory: pick.memory, vsTotal: pick.vs.total });
+  }
+  if (flags["json"] !== true)
+    write(
+      color.dim(
+        `${memories.length} memories, ${gray.length} in the gray zone; replaying ${cases.length}` + (useLlm ? " with the LLM reference" : " (Jev only)")
+      )
+    );
+  if (cases.length === 0) return 0;
+  let callLlm;
+  let llmLabel = "";
+  if (useLlm) {
+    const providerId = typeof flags["provider"] === "string" ? flags["provider"] : deps.config.provider;
+    const model = typeof flags["model"] === "string" ? flags["model"] : deps.config.model;
+    const provider = createProviderForId(
+      providerId,
+      deps.config
+    );
+    if (!provider?.complete) {
+      write(
+        color.amber(
+          `! cannot build provider "${providerId}" here; use --provider/--model or --no-llm.`
+        )
+      );
+      return 2;
+    }
+    llmLabel = `${providerId}/${model}`;
+    callLlm = async (system, user) => {
+      const response = await provider.complete(
+        {
+          model,
+          system: [{ type: "text", text: system }],
+          messages: [{ role: "user", content: user }],
+          // 60 is what `/memory triage` sends; --llm-max-tokens shows whether
+          // a reasoning model needs more room to produce any answer at all.
+          maxTokens: Math.max(16, Number(flags["llm-max-tokens"]) || 60),
+          temperature: 0.1
+        },
+        { signal: AbortSignal.timeout(6e4) }
+      );
+      return response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+    };
+  }
+  const judge = { client: account.client, model: account.model, feature: "memoryTriage" };
+  const CONCURRENCY = 6;
+  for (let i = 0; i < cases.length; i += CONCURRENCY) {
+    await Promise.all(
+      cases.slice(i, i + CONCURRENCY).map(async (c) => {
+        try {
+          c.jev = await probeMemoryValue(judge, c.memory);
+          if (c.jev) c.jevAction = await actionFor(c.memory, c.jev.score);
+        } catch (err) {
+          c.error = `jev: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        if (!callLlm) return;
+        try {
+          const r = await evaluateMemory(c.memory, computeValueScore(c.memory), callLlm);
+          if (r.evaluation.ok) {
+            c.llmScore = r.evaluation.score;
+            c.llmAction = r.action === "keep_llm_override" ? "keep" : r.action;
+          } else {
+            c.error = `llm: ${r.evaluation.error ?? "no score"}`;
+          }
+        } catch (err) {
+          c.error = `llm: ${err instanceof Error ? err.message : String(err)}`;
+        }
+      })
+    );
+  }
+  const judged = cases.filter((c) => c.jev);
+  const both = judged.filter((c) => c.llmScore !== void 0);
+  const settles = (c, minConfidence) => !!c.jev && c.jev.confidence >= minConfidence && c.jev.probability >= SYSTEM_ONE_MIN_PROBABILITY;
+  const pct = (a, b) => b === 0 ? "\u2014" : `${Math.round(a / b * 100)}%`;
+  if (flags["json"] === true) {
+    write(
+      JSON.stringify(
+        {
+          db: dbPath,
+          llm: llmLabel || null,
+          model: judged[0]?.jev?.model,
+          cases: cases.map((c) => ({
+            id: c.memory.id,
+            text: c.memory.text.slice(0, 160),
+            phase2: c.vsTotal,
+            jev: c.jev ? {
+              score: c.jev.score,
+              p: Number(c.jev.probability.toFixed(3)),
+              confidence: Number(c.jev.confidence.toFixed(3)),
+              action: c.jevAction
+            } : null,
+            llm: c.llmScore !== void 0 ? { score: c.llmScore, action: c.llmAction } : null,
+            error: c.error
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  write("");
+  write(color.bold("Jev rating distribution"));
+  const dist = [1, 2, 3, 4, 5].map((s) => judged.filter((c) => c.jev.score === s).length);
+  write(`  1:${dist[0]}  2:${dist[1]}  3:${dist[2]}  4:${dist[3]}  5:${dist[4]}`);
+  if (both.length > 0) {
+    write(color.bold(`Jev vs LLM (${llmLabel}), n=${both.length}`));
+    write(
+      `  rating exact   ${pct(both.filter((c) => c.jev.score === c.llmScore).length, both.length)}`
+    );
+    write(
+      `  rating \xB11      ${pct(both.filter((c) => Math.abs(c.jev.score - c.llmScore) <= 1).length, both.length)}`
+    );
+    write(
+      `  same action    ${pct(both.filter((c) => c.jevAction === c.llmAction).length, both.length)}`
+    );
+    write("  matrix (rows Jev 1-5, cols LLM 1-5)");
+    for (let j = 1; j <= 5; j++) {
+      const row = [1, 2, 3, 4, 5].map(
+        (l) => both.filter((c) => c.jev.score === j && c.llmScore === l).length
+      );
+      write(`    ${j}: ${row.map((n) => String(n).padStart(3)).join("")}`);
+    }
+    write("");
+    write(color.bold("Sweep (confidence threshold, p \u2265 0.5): settles / same action"));
+    for (const t of [0.3, 0.4, 0.5, 0.55, 0.6, 0.7, 0.8]) {
+      const s = both.filter((c) => settles(c, t));
+      write(
+        `  conf \u2265 ${t.toFixed(2)}${t === SYSTEM_ONE_MIN_CONFIDENCE ? " (current)" : "          "}  ${pct(s.length, both.length).padStart(4)}  ${pct(
+          s.filter((c) => c.jevAction === c.llmAction).length,
+          s.length
+        )}`
+      );
+    }
+  } else {
+    const s = judged.filter((c) => settles(c, SYSTEM_ONE_MIN_CONFIDENCE));
+    write(`  settles at current thresholds: ${pct(s.length, judged.length)}`);
+  }
+  const errors = cases.filter((c) => c.error);
+  if (errors.length > 0) {
+    write(color.amber(`${errors.length} case(s) with errors, e.g. ${errors[0]?.error}`));
+  }
+  write(color.dim(`model ${judged[0]?.jev?.model ?? account.model}`));
+  return 0;
+}
+export {
+  replayMemoryTriage
+};
+//# sourceMappingURL=typesafe-triage-replay-FGAW7QM7.js.map

package/dist/{update-5DPB4YD4.js → update-7XIOEXTD.js}

@@ -3,13 +3,14 @@ import {
   detectUpdatePackageName,
   runUpdateCommand,
   updateCmd
-} from "./chunk-DE7BZDNK.js";
+} from "./chunk-QFPQXKCG.js";
 import "./chunk-U3SS4NRH.js";
-import "./chunk-YLQEGYV4.js";
+import "./chunk-ZZRSG7VK.js";
+import "./chunk-YBUCXXYZ.js";
 export {
   detectUpdatePackageManager,
   detectUpdatePackageName,
   runUpdateCommand,
   updateCmd
 };
-//# sourceMappingURL=update-5DPB4YD4.js.map
+//# sourceMappingURL=update-7XIOEXTD.js.map

package/dist/{update-check-BS3DHTSI.js → update-check-2POMBHFB.js}

@@ -5,7 +5,8 @@ import {
   fetchLatestFromNpm,
   getUpdateNotification,
   isNewer
-} from "./chunk-YLQEGYV4.js";
+} from "./chunk-ZZRSG7VK.js";
+import "./chunk-YBUCXXYZ.js";
 export {
   cachePath,
   checkForUpdate,
@@ -14,4 +15,4 @@ export {
   getUpdateNotification,
   isNewer
 };
-//# sourceMappingURL=update-check-BS3DHTSI.js.map
+//# sourceMappingURL=update-check-2POMBHFB.js.map

package/dist/update-check.d.ts

@@ -8,7 +8,7 @@ type HomeDirFn = () => string;
 export type UpdatePackageName = 'wrongstack' | '@wrongstack/cli';
 /** Cache file path — homeFn is injectable for testing */
 export declare function cachePath(homeFn?: HomeDirFn): string;
-/** Read the current CLI version from package.json */
+/** Read the current CLI version from package.json (or the binary's build stamp). */
 export declare function currentVersion(): string;
 /** SemVer comparison — returns true if a > b. Invalid versions are never considered newer. */
 export declare function isNewer(a: string, b: string): boolean;

package/dist/version-help-WZ623NWM.js

@@ -0,0 +1,10 @@
+import {
+  helpCmd,
+  versionCmd
+} from "./chunk-2BKFWIER.js";
+import "./chunk-YBUCXXYZ.js";
+export {
+  helpCmd,
+  versionCmd
+};
+//# sourceMappingURL=version-help-WZ623NWM.js.map

package/dist/version.d.ts

@@ -1,4 +1,5 @@
 export declare const CLI_VERSION: string;
-declare let API_VERSION: string;
-export { API_VERSION };
+export declare const API_VERSION: string;
+/** Build target of the standalone executable; undefined in an npm install. */
+export declare const STANDALONE_TARGET: string | undefined;
 //# sourceMappingURL=version.d.ts.map

package/dist/webui-client-observability.d.ts

@@ -0,0 +1,7 @@
+import { type SessionAgentRegistry, startWebUILiveStatusLogger } from '@wrongstack/webui-server';
+import type { WebSocket } from 'ws';
+import type { ConnectedClient } from './webui-server/connection-handler.js';
+import type { CliWebUIOptions } from './webui-server-options.js';
+export declare function createEmbeddedClientRegistration(opts: CliWebUIOptions, clients: Map<WebSocket, ConnectedClient>, abortControllers: Map<string, AbortController>, getSessionAgents: () => SessionAgentRegistry | undefined): import("./webui-server/client-registration.js").WebuiClientRegistration;
+export declare function startEmbeddedLiveStatusLogger(opts: CliWebUIOptions, clients: Map<WebSocket, ConnectedClient>, abortControllers: Map<string, AbortController>, getSessionAgents: () => SessionAgentRegistry | undefined, terminalLogView: Parameters<typeof startWebUILiveStatusLogger>[0]['dashboard']): () => void;
+//# sourceMappingURL=webui-client-observability.d.ts.map