@stjbrown/agent-knowledge 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/{tui-GCLV5CZQ.js → tui-6F3IBI3J.js}

@@ -3,17 +3,21 @@ import { createRequire as __janetCreateRequire } from "node:module";
 const require = __janetCreateRequire(import.meta.url);
 import {
   availableModels,
-  completeOnboarding,
-  loadSettings,
-  normalizeModelSelection,
-  rememberModel
-} from "./chunk-PBRTNSWS.js";
+  normalizeModelSelection
+} from "./chunk-PUTDZMUI.js";
 import {
   GREETING,
   bootJanet,
+  completeOnboarding,
+  formatObservabilityStatus,
   getAuthStorage,
-  messageText
-} from "./chunk-H4H6S4AV.js";
+  loadSettings,
+  messageText,
+  rememberModel,
+  rememberObservability,
+  resolveObservabilityConfig,
+  safeObservabilityEndpoint
+} from "./chunk-EBMACGJV.js";
 
 // src/tui/index.ts
 import {
@@ -25,7 +29,8 @@ import {
   SelectList,
   Spacer,
   TUI,
-  Text
+  Text,
+  matchesKey
 } from "@earendil-works/pi-tui";
 
 // src/tui/activity.ts
@@ -61,6 +66,90 @@ function toolActivityLabel(toolName) {
   }
   return "Janet is working\u2026";
 }
+function toolErrorLabel(result) {
+  const detail = String(result);
+  const readRequired = detail.match(
+    /File "([^"]+)" (?:has not been read|was modified since last read)/
+  );
+  if (readRequired) {
+    return `Update paused: Janet needs to re-read "${readRequired[1]}" first.`;
+  }
+  return `Tool error: ${detail.slice(0, 140)}`;
+}
+
+// src/tui/interrupt.ts
+function createInterruptController(actions, options = {}) {
+  const doublePressMs = options.doublePressMs ?? 800;
+  const now = options.now ?? Date.now;
+  let lastCtrlC;
+  const cancelRun = () => {
+    if (!actions.isRunning()) return "ignored";
+    actions.abortRun();
+    actions.notify("cancelled");
+    return "cancelled";
+  };
+  return {
+    handleCtrlC() {
+      const pressedAt = now();
+      if (lastCtrlC !== void 0 && pressedAt - lastCtrlC < doublePressMs) {
+        actions.notify("exit");
+        actions.exit();
+        return "exit";
+      }
+      lastCtrlC = pressedAt;
+      const cancelled = cancelRun();
+      if (cancelled !== "ignored") return cancelled;
+      if (actions.hasInput()) {
+        actions.clearInput();
+        actions.notify("cleared");
+        return "cleared";
+      }
+      actions.notify("exit-hint");
+      return "exit-hint";
+    },
+    handleEscape() {
+      return cancelRun();
+    }
+  };
+}
+
+// src/tui/traces.ts
+function duration(span) {
+  if (!span.endedAt) return "running";
+  const elapsed = Math.max(0, span.endedAt.getTime() - span.startedAt.getTime());
+  return elapsed >= 1e3 ? `${(elapsed / 1e3).toFixed(1)}s` : `${elapsed}ms`;
+}
+function traceStatus(span) {
+  if (span.error) return "error";
+  return span.endedAt ? "ok" : "running";
+}
+function formatTraceTree(spans) {
+  const byParent = /* @__PURE__ */ new Map();
+  const ids = new Set(spans.map((span) => span.spanId));
+  for (const span of spans) {
+    const parent = span.parentSpanId && ids.has(span.parentSpanId) ? span.parentSpanId : null;
+    const children = byParent.get(parent) ?? [];
+    children.push(span);
+    byParent.set(parent, children);
+  }
+  for (const children of byParent.values()) {
+    children.sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
+  }
+  const lines = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (span, depth) => {
+    if (visited.has(span.spanId)) return;
+    visited.add(span.spanId);
+    const status = traceStatus(span);
+    const marker = status === "error" ? "\u2717" : status === "running" ? "\u2026" : "\u2713";
+    lines.push(
+      `${"  ".repeat(depth)}${marker} ${span.name} \xB7 ${span.spanType} \xB7 ${duration(span)}`
+    );
+    for (const child of byParent.get(span.spanId) ?? []) visit(child, depth + 1);
+  };
+  for (const root of byParent.get(null) ?? []) visit(root, 0);
+  return lines;
+}
 
 // src/tui/theme.ts
 import chalk from "chalk";
@@ -103,16 +192,6 @@ var markdownTheme = {
 
 // src/tui/index.ts
 var OAUTH_PROVIDERS = ["anthropic", "openai-codex"];
-var JanetEditor = class extends Editor {
-  onCtrlC;
-  handleInput(data) {
-    if (data === "") {
-      this.onCtrlC?.();
-      return;
-    }
-    super.handleInput(data);
-  }
-};
 var HELP_TEXT = `Commands:
   /models                Pick a model from a list (arrow keys)
   /model [provider/id]   Open the picker, or switch directly by id
@@ -120,9 +199,13 @@ var HELP_TEXT = `Commands:
                          Log in; OpenAI mode is browser or device
   /logout <provider>     Remove stored credentials for a provider
   /auth                  Show which providers are authenticated
+  /observability         Configure opt-in tracing
+  /traces                Browse recent local traces
+  /cancel                Cancel the active run
   /help                  This help
   /quit                  Exit (double Ctrl+C also works)
 
+While Janet is working, Esc or Ctrl+C cancels the active run.
 Anything else is a message to Janet.`;
 function resolveAnswer(q, text) {
   if (!q.options?.length) return text;
@@ -143,7 +226,10 @@ function resolveAnswer(q, text) {
   return pick(text);
 }
 async function runTui(opts) {
-  const { controller, session, paths, herdrDetach } = await bootJanet({ ...opts, interactive: true });
+  const { controller, session, paths, herdrDetach, observability } = await bootJanet({
+    ...opts,
+    interactive: true
+  });
   const persistedModel = process.env["JANET_MODEL"] || loadSettings().defaultModelId;
   const presetModel = persistedModel ? normalizeModelSelection(persistedModel, availableModels()) : void 0;
   if (!session.model.hasSelection() && presetModel) {
@@ -153,7 +239,7 @@ async function runTui(opts) {
   const ui = new TUI(terminal);
   const chat = new Container();
   const status = new Text("", 1, 0);
-  const editor = new JanetEditor(ui, editorTheme);
+  const editor = new Editor(ui, editorTheme);
   const loader = new Loader(ui, c.accent, c.dim, "Janet is thinking\u2026");
   ui.addChild(chat);
   ui.addChild(new Spacer(1));
@@ -166,11 +252,15 @@ async function runTui(opts) {
   let pendingInput = null;
   let activeSelect = null;
   let active = null;
+  let cancelRequested = false;
   const activeTools = /* @__PURE__ */ new Map();
   const updateStatus = () => {
     const model = session.model.hasSelection() ? session.model.get() : "no model \u2014 /model <id>";
-    const state = pendingInput ? "enter the requested value" : pendingQuestion || activeSelect ? "answer Janet's question" : pendingApproval ? "awaiting approval" : running ? "working" : "idle";
-    status.setText(c.dim(`${paths.projectPath}  \xB7  `) + c.accent(model) + c.dim(`  \xB7  ${state}`));
+    const tracing = observability.status.enabled ? c.dim(`  \xB7  trace:${observability.status.capture}`) : "";
+    const state = pendingInput ? "enter the requested value" : pendingQuestion || activeSelect ? "answer Janet's question" : pendingApproval ? "awaiting approval" : cancelRequested ? "cancelling" : running ? "working \xB7 Esc/Ctrl+C cancels" : "idle";
+    status.setText(
+      c.dim(`${paths.projectPath}  \xB7  `) + c.accent(model) + c.dim(`  \xB7  ${state}`) + tracing
+    );
     ui.requestRender();
   };
   const appendToChat = (comp) => {
@@ -217,6 +307,7 @@ async function runTui(opts) {
     switch (event.type) {
       case "agent_start":
         running = true;
+        cancelRequested = false;
         active = null;
         activeTools.clear();
         loader.setMessage("Janet is thinking\u2026");
@@ -257,7 +348,7 @@ async function runTui(opts) {
         );
         if (event.isError) {
           closeSegment();
-          addLine(c.warn(`  Tool error: ${String(event.result).slice(0, 140)}`));
+          addLine(c.warn(`  ${toolErrorLabel(event.result)}`));
         }
         break;
       case "tool_suspended": {
@@ -318,6 +409,7 @@ async function runTui(opts) {
         break;
       case "agent_end":
         running = false;
+        cancelRequested = false;
         activeTools.clear();
         loader.setMessage("Janet is thinking\u2026");
         if (event.reason !== "suspended") pendingQuestion = null;
@@ -327,20 +419,84 @@ async function runTui(opts) {
     }
   };
   const unsubscribe = session.subscribe(onEvent);
+  let removeInputListener = () => {
+  };
+  let sigintHandler;
   const shutdown = async (code) => {
+    removeInputListener();
+    if (sigintHandler) process.off("SIGINT", sigintHandler);
     unsubscribe();
     herdrDetach();
     ui.stop();
+    await observability.flush().catch(() => {
+    });
     await controller.destroy().catch(() => {
     });
     process.exit(code);
   };
+  const notifyInterrupt = (result) => {
+    switch (result) {
+      case "cancelled":
+        addLine(c.dim("  Cancelling the active run\u2026"));
+        break;
+      case "cleared":
+        break;
+      case "exit":
+        break;
+      case "exit-hint":
+        addLine(c.dim("  Press Ctrl+C again to quit."));
+        break;
+    }
+    updateStatus();
+  };
+  const abortActiveRun = () => {
+    if (cancelRequested) return;
+    cancelRequested = true;
+    pendingApproval = null;
+    pendingQuestion = null;
+    activeTools.clear();
+    if (activeSelect) {
+      chat.removeChild(activeSelect);
+      activeSelect = null;
+    }
+    ui.setFocus(editor);
+    loader.setMessage("Cancelling\u2026");
+    session.abort();
+  };
+  const interrupts = createInterruptController({
+    isRunning: () => running,
+    hasInput: () => editor.getText().length > 0,
+    abortRun: abortActiveRun,
+    clearInput: () => {
+      editor.setText("");
+      ui.requestRender();
+    },
+    exit: () => {
+      void shutdown(0);
+    },
+    notify: notifyInterrupt
+  });
+  removeInputListener = ui.addInputListener((data) => {
+    if (matchesKey(data, "ctrl+c")) {
+      interrupts.handleCtrlC();
+      return { consume: true };
+    }
+    if (matchesKey(data, "escape") && running) {
+      interrupts.handleEscape();
+      return { consume: true };
+    }
+    return void 0;
+  });
+  sigintHandler = () => {
+    interrupts.handleCtrlC();
+  };
+  process.on("SIGINT", sigintHandler);
   const promptInput = (message, placeholder) => {
     addLine(c.accentBold(`  ${message}`));
     if (placeholder) addLine(c.dim(`  (${placeholder})`));
-    updateStatus();
     return new Promise((resolve) => {
       pendingInput = resolve;
+      updateStatus();
     });
   };
   const showModelPicker = (intro) => {
@@ -380,6 +536,254 @@ async function runTui(opts) {
     ui.setFocus(select);
     updateStatus();
   };
+  const savedObservabilitySummary = () => {
+    const saved = loadSettings().observability;
+    const resolved = resolveObservabilityConfig(saved, {});
+    return formatObservabilityStatus({
+      enabled: resolved.enabled,
+      capture: resolved.capture,
+      sampleRate: resolved.sampleRate,
+      destinations: [
+        ...resolved.local.enabled ? ["local"] : [],
+        ...resolved.remote ? [
+          resolved.remote.kind === "phoenix" ? `phoenix (${safeObservabilityEndpoint(resolved.remote.endpoint)})` : `otlp (${safeObservabilityEndpoint(resolved.remote.endpoint)})`
+        ] : []
+      ],
+      warnings: resolved.warnings
+    });
+  };
+  const persistObservability = (settings) => {
+    rememberObservability(settings);
+    addLine(c.accentBold("  \u2713 Observability settings saved."));
+    addLine(c.dim(`  Saved: ${savedObservabilitySummary()}`));
+    addLine(c.dim("  Restart Janet to apply the new setting."));
+    updateStatus();
+  };
+  const closeActiveSelect = (select) => {
+    chat.removeChild(select);
+    if (activeSelect === select) activeSelect = null;
+    ui.setFocus(editor);
+  };
+  const confirmFullCapture = (base) => {
+    addLine(
+      c.warn(
+        "  Full capture includes prompts, responses, and tool payloads. Do not use it with sensitive material."
+      )
+    );
+    const select = new SelectList(
+      [
+        {
+          value: "no",
+          label: "Keep metadata-only capture",
+          description: "Recommended. Content stays out of traces."
+        },
+        {
+          value: "yes",
+          label: "Enable full capture",
+          description: "I understand trace content may contain sensitive data."
+        }
+      ],
+      2,
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      persistObservability({
+        ...base,
+        capture: item.value === "yes" ? "full" : "metadata"
+      });
+    };
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const chooseCaptureMode = (base) => {
+    addLine(c.accentBold("  What may Janet include in traces?"));
+    const select = new SelectList(
+      [
+        {
+          value: "metadata",
+          label: "Metadata only",
+          description: "Timing, tool names, model, tokens, status, and errors."
+        },
+        {
+          value: "full",
+          label: "Full content",
+          description: "Also includes prompts, responses, and tool payloads."
+        }
+      ],
+      2,
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      const capture = item.value;
+      if (capture === "full") {
+        confirmFullCapture(base);
+      } else {
+        persistObservability({ ...base, capture });
+      }
+    };
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const showObservabilityPicker = () => {
+    if (running) {
+      addLine(c.dim("  Cancel the active run before changing observability settings."));
+      return;
+    }
+    addLine(c.accentBold("  Configure observability"));
+    addLine(c.dim(`  Active now: ${formatObservabilityStatus(observability.status)}`));
+    addLine(c.dim("  Tracing is opt-in and changes apply after restart."));
+    const select = new SelectList(
+      [
+        {
+          value: "off",
+          label: "Off",
+          description: "No spans, trace database, or network export."
+        },
+        {
+          value: "local",
+          label: "Local trace history",
+          description: "Store traces in ~/.agent-knowledge/observability.db."
+        },
+        {
+          value: "phoenix",
+          label: "Phoenix",
+          description: "Send OTLP traces to http://localhost:6006."
+        },
+        {
+          value: "otlp",
+          label: "Custom OTLP",
+          description: "Send OTLP/HTTP protobuf traces to your endpoint."
+        }
+      ],
+      4,
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      if (item.value === "off") {
+        persistObservability({
+          capture: "off",
+          sampleRate: 1,
+          local: { enabled: false, retentionDays: 7 }
+        });
+        return;
+      }
+      if (item.value === "local") {
+        chooseCaptureMode({
+          sampleRate: 1,
+          local: { enabled: true, retentionDays: 7 }
+        });
+        return;
+      }
+      if (item.value === "phoenix") {
+        chooseCaptureMode({
+          sampleRate: 1,
+          local: { enabled: false, retentionDays: 7 },
+          remote: {
+            kind: "phoenix",
+            endpoint: "http://localhost:6006",
+            projectName: "janet"
+          }
+        });
+        return;
+      }
+      void promptInput(
+        "OTLP endpoint (for example, http://localhost:4318):"
+      ).then((endpoint) => {
+        try {
+          const parsed = new URL(endpoint);
+          if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error();
+          if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+            addLine(
+              c.error(
+                "  Do not put credentials or query parameters in the saved endpoint. Use OTEL_EXPORTER_OTLP_HEADERS."
+              )
+            );
+            return;
+          }
+        } catch {
+          addLine(c.error("  Endpoint must be a valid HTTP or HTTPS URL."));
+          return;
+        }
+        chooseCaptureMode({
+          sampleRate: 1,
+          local: { enabled: false, retentionDays: 7 },
+          remote: {
+            kind: "otlp",
+            endpoint
+          }
+        });
+      });
+    };
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const showLocalTraces = async () => {
+    if (running) {
+      addLine(c.dim("  Cancel the active run before browsing traces."));
+      return;
+    }
+    if (!observability.config.local.enabled) {
+      addLine(c.dim("  Local trace history is not active. Use /observability to enable it."));
+      return;
+    }
+    await observability.flush().catch(() => {
+    });
+    const store = await observability.storage.getStore("observability");
+    if (!store) {
+      addLine(c.error("  Local trace storage is unavailable."));
+      return;
+    }
+    const recent = await store.listTraces({
+      pagination: { page: 0, perPage: 10 },
+      orderBy: { field: "startedAt", direction: "DESC" }
+    });
+    if (!recent.spans.length) {
+      addLine(c.dim("  No local traces yet."));
+      return;
+    }
+    addLine(c.accentBold("  Recent local traces"));
+    const select = new SelectList(
+      recent.spans.map((span) => {
+        const state = traceStatus(span);
+        const marker = state === "error" ? "\u2717" : state === "running" ? "\u2026" : "\u2713";
+        return {
+          value: span.traceId,
+          label: `${marker} ${span.name}`,
+          description: `${span.startedAt.toLocaleString()} \xB7 ${span.traceId}`
+        };
+      }),
+      Math.min(recent.spans.length, 10),
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      void store.getTrace({ traceId: item.value }).then((trace) => {
+        if (!trace) {
+          addLine(c.error(`  Trace not found: ${item.value}`));
+          return;
+        }
+        addLine(c.accentBold(`  Trace ${trace.traceId}`));
+        for (const line of formatTraceTree(trace.spans)) {
+          addLine(c.dim(`  ${line}`));
+        }
+      }).catch((error) => {
+        addLine(c.error(`  Could not read trace: ${error.message}`));
+      });
+    };
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
   const handleCommand = async (text) => {
     const [cmd, ...rest] = text.slice(1).split(/\s+/);
     switch (cmd) {
@@ -390,6 +794,32 @@ async function runTui(opts) {
       case "help":
         addLine(c.dim(HELP_TEXT));
         break;
+      case "cancel":
+        if (interrupts.handleEscape() === "ignored") {
+          addLine(c.dim("  No active run to cancel."));
+        }
+        break;
+      case "observability": {
+        const action = rest[0]?.trim().toLowerCase();
+        if (action === "status") {
+          addLine(c.dim(`  Active: ${formatObservabilityStatus(observability.status)}`));
+          addLine(c.dim(`  Saved:  ${savedObservabilitySummary()}`));
+        } else if (action === "off") {
+          persistObservability({
+            capture: "off",
+            sampleRate: 1,
+            local: { enabled: false, retentionDays: 7 }
+          });
+        } else if (!action) {
+          showObservabilityPicker();
+        } else {
+          addLine(c.dim("Usage: /observability [status | off]"));
+        }
+        break;
+      }
+      case "traces":
+        await showLocalTraces();
+        break;
       case "login": {
         const providerId = (rest[0] || "anthropic").trim();
         if (!OAUTH_PROVIDERS.includes(providerId)) {
@@ -523,31 +953,21 @@ async function runTui(opts) {
       showModelPicker("  Pick a model first:");
       return;
     }
-    void session.sendMessage({ content: text }).catch((err) => {
+    void session.sendMessage({
+      content: text,
+      tracingOptions: observability.tracingOptionsForTurn({
+        interactive: true,
+        operation: "chat",
+        resourceId: paths.resourceId,
+        threadId: session.thread.getId() ?? void 0
+      })
+    }).catch((err) => {
       running = false;
       setLoader(false);
       addLine(c.error(`  \u2717 ${err.message}`));
       updateStatus();
     });
   };
-  let lastCtrlC = 0;
-  editor.onCtrlC = () => {
-    const now = Date.now();
-    if (now - lastCtrlC < 800) {
-      void shutdown(0);
-      return;
-    }
-    lastCtrlC = now;
-    if (running) {
-      void session.abort();
-      addLine(c.dim("  (aborted \u2014 Ctrl+C again to quit)"));
-    } else if (editor.getText()) {
-      editor.setText("");
-      ui.requestRender();
-    } else {
-      addLine(c.dim("  (Ctrl+C again to quit)"));
-    }
-  };
   addLine(c.accentBold(GREETING));
   addLine(
     c.dim(
@@ -555,6 +975,9 @@ async function runTui(opts) {
 Ask me anything in the bundle, or say what to ingest. /help for commands.`
     )
   );
+  for (const warning of observability.status.warnings) {
+    addLine(c.warn(`Observability: ${warning}`));
+  }
   updateStatus();
   ui.start();
   ui.setFocus(editor);
@@ -566,4 +989,4 @@ Ask me anything in the bundle, or say what to ingest. /help for commands.`
 export {
   runTui
 };
-//# sourceMappingURL=tui-GCLV5CZQ.js.map
+//# sourceMappingURL=tui-6F3IBI3J.js.map