@corenel/term 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @corenel/term
+
+Corenel's terminal face: a headless chat controller and the [Ink](https://github.com/vadimdemedes/ink)
+views that render it. Published so [`@corenel/cli`](https://www.npmjs.com/package/@corenel/cli)
+can depend on it; usable directly if you are building a terminal agent of your own.
+
+Requires Node 18+.
+
+## The split that matters
+
+`./session` and its siblings are **Ink-free**. Only `./ink` pulls in React.
+
+That is deliberate: the CLI runs the same controller behind two faces — the full
+terminal UI on a TTY, and a plain readline loop when output is piped, under
+`TERM=dumb`, in CI, or with `--no-tui`. Both drive one controller, so a fix to
+turn handling lands in both faces at once rather than in whichever one somebody
+remembered.
+
+| Export | What it is | Pulls React |
+| --- | --- | --- |
+| `./session` | The turn controller — runs a turn, emits deltas | no |
+| `./state` | The conversation state a face renders | no |
+| `./commands` | Slash commands (`/clear`, `/resume`, …) | no |
+| `./describe` | Human-readable renderings of harness events | no |
+| `./persist` | Save and reopen conversations | no |
+| `./ink` | The full terminal UI: scrollback, live tail, modals, palette | **yes** |
+
+```ts
+import { TermSession } from '@corenel/term/session';
+```
+
+## Packaging
+
+`dist/` is bundled (see `build.mjs`): `@corenel/harness` and `@corenel/protocol`
+are inlined at build time and are **not** runtime dependencies. The only things
+installed alongside this package are `ink`, `ink-text-input`, `openai` and
+`react`.
+
+One consequence worth knowing before you use this from TypeScript: the published
+`.d.ts` files still reference `@corenel/harness` and `@corenel/protocol` for
+types. The JavaScript runs without them, but a TypeScript consumer needs both
+installed for those types to resolve. Both are on npm.
+
+Licensed under Elastic-2.0.

package/dist/chunk-47IH6X5H.js

@@ -0,0 +1,20 @@
+// src/state.ts
+function emptyState() {
+  return {
+    seq: 0,
+    transcriptGen: 0,
+    committed: [],
+    live: null,
+    queued: [],
+    modal: null,
+    usage: { promptTokens: 0, completionTokens: 0 },
+    turnUsage: { promptTokens: 0, completionTokens: 0 },
+    session: null,
+    status: "idle",
+    error: null
+  };
+}
+
+export {
+  emptyState
+};

package/dist/chunk-HAQGHLW6.js

@@ -0,0 +1,235 @@
+// ../protocol/files.ts
+function flattenFiles(nodes, out = []) {
+  for (const n of nodes) {
+    if (n.kind === "file") out.push(n);
+    if (n.children?.length) flattenFiles(n.children, out);
+  }
+  return out;
+}
+
+// ../protocol/stateDir.ts
+var DEFAULT_STATE_DIR = ".corenel";
+var dirName = DEFAULT_STATE_DIR;
+function sessionsRoot() {
+  return `${dirName}/sessions`;
+}
+
+// ../harness/sessions/jsonl.ts
+function encodeLine(line) {
+  return JSON.stringify(line) + "\n";
+}
+function foldSession(text) {
+  let meta = null;
+  const turns = [];
+  let title = "";
+  let titleLocked;
+  let updatedAt = 0;
+  for (const raw of text.split("\n")) {
+    const s = raw.trim();
+    if (!s) continue;
+    let line;
+    try {
+      line = JSON.parse(s);
+    } catch {
+      continue;
+    }
+    if (line.k === "meta" && !meta && typeof line.id === "string" && typeof line.createdAt === "number") {
+      meta = line;
+      title = typeof line.title === "string" ? line.title : "";
+      updatedAt = Math.max(updatedAt, line.createdAt);
+    } else if (line.k === "meta-update" && typeof line.at === "number") {
+      if (typeof line.title === "string") title = line.title;
+      if (typeof line.titleLocked === "boolean") titleLocked = line.titleLocked;
+      updatedAt = Math.max(updatedAt, line.at);
+    } else if (line.k === "turn" && Number.isInteger(line.i) && line.i >= 0 && typeof line.at === "number") {
+      turns[line.i] = line.m;
+      updatedAt = Math.max(updatedAt, line.at);
+    }
+  }
+  if (!meta) return null;
+  return {
+    id: meta.id,
+    title,
+    createdAt: meta.createdAt,
+    updatedAt: updatedAt || meta.createdAt,
+    messages: turns.filter((t) => t !== void 0),
+    ...meta.surface ? { surface: meta.surface } : {},
+    ...titleLocked !== void 0 ? { titleLocked } : {}
+  };
+}
+
+// ../harness/sessions/fileSessionStore.ts
+function uid(prefix) {
+  return `${prefix}_${Date.now().toString(36)}${Math.floor(Math.random() * 1e6).toString(36)}`;
+}
+var lastTs = 0;
+function now() {
+  const t = Date.now();
+  lastTs = t > lastTs ? t : lastTs + 1;
+  return lastTs;
+}
+var JsonlSessionStore = class {
+  constructor(getFiles, root = sessionsRoot) {
+    this.getFiles = getFiles;
+    this.root = root;
+  }
+  cursors = /* @__PURE__ */ new Map();
+  async files() {
+    const f = await this.getFiles();
+    if (!f) throw new Error("No file workspace is connected \u2014 sessions are unavailable.");
+    return f;
+  }
+  path(id) {
+    return `${this.root()}/${id}/SESSION.jsonl`;
+  }
+  async create(title, surface) {
+    const createdAt = now();
+    const id = uid("ses");
+    const meta = { k: "meta", id, title, createdAt, ...surface ? { surface } : {} };
+    const text = encodeLine(meta);
+    await (await this.files()).write(this.path(id), text);
+    this.cursors.set(id, { text, turnJson: [], title });
+    return { id, title, createdAt, updatedAt: createdAt, messages: [], ...surface ? { surface } : {} };
+  }
+  async get(id) {
+    const text = await (await this.files()).read(this.path(id)).catch(() => null);
+    if (text == null) return null;
+    const ses = foldSession(text);
+    if (ses) {
+      this.cursors.set(id, {
+        text,
+        turnJson: ses.messages.map((m) => JSON.stringify(m)),
+        title: ses.title,
+        titleLocked: ses.titleLocked
+      });
+    }
+    return ses;
+  }
+  async list(surface) {
+    const files = await this.files();
+    const root = this.root();
+    const nodes = await files.list(root).catch(() => []);
+    const sessionFiles = flattenFiles(nodes).filter((f) => f.name === "SESSION.jsonl" && f.path.startsWith(root + "/"));
+    const out = [];
+    for (const f of sessionFiles) {
+      const text = await files.read(f.path).catch(() => null);
+      const ses = text != null ? foldSession(text) : null;
+      if (ses) out.push(ses);
+    }
+    const scoped = surface ? out.filter((s) => s.surface === surface || surface === "agent" && !s.surface) : out;
+    return scoped.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async save(session) {
+    const at = now();
+    const cur = this.cursors.get(session.id) ?? await this.seed(session);
+    const turnJson = session.messages.map((m) => JSON.stringify(m));
+    const appended = [];
+    for (let i = 0; i < turnJson.length; i++) {
+      if (cur.turnJson[i] !== turnJson[i]) {
+        appended.push(encodeLine({ k: "turn", i, at, m: session.messages[i] }));
+      }
+    }
+    if (session.title !== cur.title || session.titleLocked !== cur.titleLocked) {
+      appended.push(encodeLine({
+        k: "meta-update",
+        at,
+        title: session.title,
+        ...session.titleLocked !== void 0 ? { titleLocked: session.titleLocked } : {}
+      }));
+    }
+    if (!appended.length) return;
+    session.updatedAt = at;
+    const text = cur.text + appended.join("");
+    await (await this.files()).write(this.path(session.id), text);
+    this.cursors.set(session.id, { text, turnJson, title: session.title, titleLocked: session.titleLocked });
+  }
+  /** Cursor for a session this instance hasn't touched (e.g. saved after a
+   * reload): fold the existing file, or start a fresh log from the session's
+   * own meta. */
+  async seed(session) {
+    const text = await (await this.files()).read(this.path(session.id)).catch(() => null);
+    if (text != null) {
+      const ses = foldSession(text);
+      if (ses) {
+        return { text, turnJson: ses.messages.map((m) => JSON.stringify(m)), title: ses.title, titleLocked: ses.titleLocked };
+      }
+    }
+    const meta = encodeLine({
+      k: "meta",
+      id: session.id,
+      title: session.title,
+      createdAt: session.createdAt,
+      ...session.surface ? { surface: session.surface } : {}
+    });
+    return { text: meta, turnJson: [], title: session.title, titleLocked: void 0 };
+  }
+  async rename(id, title) {
+    const cur = this.cursors.get(id);
+    const text = cur?.text ?? await (await this.files()).read(this.path(id)).catch(() => null);
+    if (text == null) return;
+    const next = text + encodeLine({ k: "meta-update", at: now(), title, titleLocked: true });
+    await (await this.files()).write(this.path(id), next);
+    const folded = foldSession(next);
+    if (folded) {
+      this.cursors.set(id, { text: next, turnJson: folded.messages.map((m) => JSON.stringify(m)), title, titleLocked: true });
+    }
+  }
+  async delete(id) {
+    this.cursors.delete(id);
+    await (await this.files()).remove(`${this.root()}/${id}`).catch(() => {
+    });
+  }
+};
+
+// src/persist.ts
+function createSessionPersistence(files) {
+  const store = new JsonlSessionStore(() => files, () => sessionsRoot());
+  return {
+    async save(input) {
+      const session = input.id ? await store.get(input.id) : await store.create(input.title, "agent");
+      if (!session) {
+        const fresh = await store.create(input.title, "agent");
+        fresh.messages = input.messages;
+        await store.save(fresh);
+        return { id: fresh.id };
+      }
+      session.messages = input.messages;
+      await store.save(session);
+      return { id: session.id };
+    },
+    async load(id) {
+      if (id) {
+        const s = await store.get(id);
+        return s ? { id: s.id, title: s.title, messages: s.messages } : null;
+      }
+      const all = await store.list("agent");
+      const newest = [...all].sort((a, b) => b.updatedAt - a.updatedAt)[0];
+      return newest ? { id: newest.id, title: newest.title, messages: newest.messages } : null;
+    },
+    list: () => store.list("agent")
+  };
+}
+function committedFromMessages(messages) {
+  const items = [];
+  let n = 0;
+  for (const m of messages) {
+    if (m.role === "user" && typeof m.content === "string") {
+      items.push({ kind: "user", id: `h${n++}`, text: m.content });
+    } else if (m.role === "assistant" && typeof m.content === "string" && m.content.trim()) {
+      items.push({ kind: "assistant", id: `h${n++}`, text: m.content });
+    }
+  }
+  return items;
+}
+function titleFrom(messages) {
+  const first = messages.find((m) => m.role === "user");
+  const text = typeof first?.content === "string" ? first.content : "";
+  const line = text.split("\n")[0].trim();
+  return line.length > 60 ? `${line.slice(0, 59)}\u2026` : line || "conversation";
+}
+
+export {
+  createSessionPersistence,
+  committedFromMessages,
+  titleFrom
+};