@corenel/term 0.2.8 → 0.3.0

package/dist/{chunk-L4KCEKIT.js → chunk-2MGDL3I4.js}

@@ -1,7 +1,8 @@
 // src/state.ts
-function emptyState() {
+function emptyState(model = "") {
   return {
     seq: 0,
+    model,
     transcriptGen: 0,
     committed: [],
     live: null,
@@ -14,7 +15,11 @@ function emptyState() {
     status: "idle",
     error: null,
     todos: [],
-    pendingSkill: null
+    pendingSkill: null,
+    sentTokens: null,
+    offloaded: [],
+    checkpoints: [],
+    toolNames: []
   };
 }
 var TODO_STATUSES = ["pending", "in_progress", "completed", "blocked"];

package/dist/chunk-5RPHYXND.js

@@ -0,0 +1,138 @@
+// src/commands.ts
+var TERM_COMMANDS = [
+  { name: "help", summary: "what you can type here" },
+  { name: "tools", summary: "what the agent can do, and what it can change" },
+  { name: "policy", summary: "how this session is governed -- levels, caps, and what actually confines it" },
+  { name: "context", summary: "what is in the context window right now -- fill, offloads, and compaction seams" },
+  { name: "expand", args: "<#n>", summary: "re-print a tool result in full" },
+  { name: "resume", args: "[id]", summary: "reopen an earlier conversation" },
+  { name: "clear", summary: "forget the conversation" },
+  { name: "exit", summary: "leave" },
+  // -- config-workspace commands: what these do to the NEXT turn is real, see
+  // TermSessionDeps.system in ./session (the re-derivable system prompt) and
+  // the `mode`/`persona`/`skill`/`strategy` cases in runCommand.
+  { name: "model", args: "<id>", summary: "list available models (read-only) -- the model is fixed for a session, so an id is refused; restart with --model <id> to change it" },
+  { name: "mode", args: "<id>", summary: "switch the agent mode (takes effect next turn); no id lists what is configured" },
+  { name: "persona", args: "<id>", summary: "switch persona (takes effect next turn); no id lists what is configured" },
+  { name: "skill", args: "<name>", summary: "apply a skill to your NEXT message only, then it clears; no name lists what is installed" },
+  { name: "strategy", args: "<name>", summary: "run a saved strategy from .prompd/strategies; no name lists what is saved" },
+  { name: "mcp", args: "[list|add|remove|login|refresh|forget]", summary: "MCP servers -- what is connected, and sign in or add one; no argument opens the manager" }
+];
+function formatHelpText() {
+  const width = Math.max(...TERM_COMMANDS.map((c) => `${c.name} ${c.args ?? ""}`.trim().length));
+  const lines = TERM_COMMANDS.map((c) => {
+    const usage = `${c.name} ${c.args ?? ""}`.trim();
+    return `  /${usage.padEnd(width)}  ${c.summary}`;
+  });
+  return [
+    "Type a request and press enter.",
+    "",
+    ...lines,
+    "",
+    /* Deliberately not 'esc stops a turn': this text is shared, and Escape is
+     * an Ink-only key -- the readline fallback has no key handler at all, so
+     * there Ctrl-C is the only way to stop a turn. Name the one that is true
+     * on both faces, and mark the other as what it is. */
+    "Ctrl-C stops a turn; twice leaves. Ctrl-D leaves. In the full terminal face, esc also stops a turn."
+  ].join("\n");
+}
+var ALIASES = { quit: "exit" };
+function isKnownCommandWord(word) {
+  const w = word.toLowerCase();
+  return w in ALIASES || TERM_COMMANDS.some((c) => c.name === w);
+}
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const d = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) d[i][0] = i;
+  for (let j = 0; j <= n; j++) d[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+    }
+  }
+  return d[m][n];
+}
+function suggestCommand(word) {
+  const w = word.toLowerCase();
+  let best = null;
+  let bestDist = Infinity;
+  for (const c of TERM_COMMANDS) {
+    const dist = editDistance(w, c.name);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = c.name;
+    }
+  }
+  if (best && bestDist <= 2 && bestDist < Math.max(w.length, best.length)) return best;
+  return null;
+}
+function unknownCommandMessage(word) {
+  const suggestion = suggestCommand(word);
+  return `unknown command /${word}${suggestion ? ` -- did you mean /${suggestion}?` : ""} -- /help lists what's available. Press enter again on the same line to send it as a message instead.`;
+}
+function parseCommand(line) {
+  const t = line.trim();
+  if (!t.startsWith("/")) return null;
+  const [wordRaw, ...rest] = t.slice(1).split(/\s+/);
+  const word = ALIASES[wordRaw.toLowerCase()] ?? wordRaw.toLowerCase();
+  const arg = rest.join(" ").trim();
+  switch (word) {
+    case "help":
+      return { cmd: "help" };
+    case "tools":
+      return { cmd: "tools" };
+    case "policy":
+      return { cmd: "policy" };
+    case "context":
+      return { cmd: "context" };
+    case "clear":
+      return { cmd: "clear" };
+    case "exit":
+      return { cmd: "exit" };
+    case "expand": {
+      const m = /^#?(\d+)$/.exec(arg);
+      return m ? { cmd: "expand", ord: Number(m[1]) } : { cmd: "expand" };
+    }
+    case "resume":
+      return arg ? { cmd: "resume", id: arg } : { cmd: "resume" };
+    case "model":
+      return arg ? { cmd: "model", id: arg } : { cmd: "model" };
+    case "mode":
+      return arg ? { cmd: "mode", id: arg } : { cmd: "mode" };
+    case "persona":
+      return arg ? { cmd: "persona", id: arg } : { cmd: "persona" };
+    case "skill":
+      return arg ? { cmd: "skill", id: arg } : { cmd: "skill" };
+    case "strategy":
+      return arg ? { cmd: "strategy", id: arg } : { cmd: "strategy" };
+    case "mcp": {
+      if (!arg) return { cmd: "mcp" };
+      const [sub, ...restArgs] = arg.split(/\s+/);
+      const known = ["list", "add", "remove", "login", "refresh", "forget"];
+      const match = known.find((k) => k === sub.toLowerCase());
+      if (!match) return { cmd: "mcp", unknown: sub };
+      return restArgs.length ? { cmd: "mcp", sub: match, args: restArgs } : { cmd: "mcp", sub: match };
+    }
+    default:
+      return null;
+  }
+}
+function filterCommands(input) {
+  const t = input.trim();
+  if (!t.startsWith("/")) return [];
+  const prefix = t.slice(1).split(/\s+/)[0].toLowerCase();
+  return TERM_COMMANDS.filter((c) => c.name.startsWith(prefix));
+}
+
+export {
+  TERM_COMMANDS,
+  formatHelpText,
+  isKnownCommandWord,
+  suggestCommand,
+  unknownCommandMessage,
+  parseCommand,
+  filterCommands
+};