pi-optchat 0.6.6 → 0.6.8

package/src/settings-page.ts

@@ -0,0 +1,160 @@
+import { Container, fuzzyFilter, getKeybindings, Input, SelectList, SettingsList, Spacer, Text, type Component, type SelectItem, type SettingItem } from '@earendil-works/pi-tui';
+import { DynamicBorder, type ExtensionContext, type Theme } from '@earendil-works/pi-coding-agent';
+import { defaults, THINKING, type ProfileConfig } from './profiles.ts';
+import { invalid, isNumberKey, SETTING_KEYS, SETTINGS, type NumberKey, type SettingKey } from './settings.ts';
+import type { ModelChoice } from './compactor.ts';
+
+type Role = 'compactor' | 'subagent';
+const ROLES: Record<Role, { label: string; description: string; applies: string }> = {
+  compactor: { label: 'Compactor model', description: 'Writes memory summaries, imports and connected-window handoffs. Shortcut: /optchat model.', applies: 'Applies to the next summary.' },
+  subagent: { label: 'Subagent model', description: 'Runs every subagent. Shortcut: /optchat agents model.', applies: 'Applies to subagents started after this.' },
+};
+const modelName = (choice: ModelChoice) => `${choice.provider}/${choice.model}`;
+const showModel = (choice: ModelChoice) => `${modelName(choice)} · ${choice.thinking}`;
+/** The value column: the model, then whether it is the default (shown short, without its provider). */
+const modelValue = (theme: Theme, role: Role, choice: ModelChoice) => `${showModel(choice)}${theme.fg('dim', showModel(choice) === showModel(defaults[role])
+  ? '  default' : `  default ${defaults[role].model} · ${defaults[role].thinking}`)}`;
+const show = (key: SettingKey, value: number | boolean) => {
+  const spec = SETTINGS[key];
+  return typeof value === 'boolean' ? value ? 'on' : 'off' : spec.kind === 'number' && spec.unit ? `${value} ${spec.unit}` : String(value);
+};
+
+interface Options {
+  profile: string; config: ProfileConfig; models: string[];
+  /** Saves the whole profile config; throws if it can't be written. */
+  save: (config: ProfileConfig) => void;
+}
+
+/** A titled step inside the page: what it changes, the control, and its keys. */
+function step(theme: Theme, title: string, description: string, control: Component, hint: string, extra: Component[] = []) {
+  const box = new Container();
+  for (const child of [new Text(theme.bold(theme.fg('accent', title)), 0, 0), new Spacer(1), new Text(theme.fg('muted', description), 0, 0),
+    new Spacer(1), control, ...extra, new Spacer(1), new Text(theme.fg('dim', hint), 0, 0)]) box.addChild(child);
+  return box;
+}
+const listTheme = (theme: Theme) => ({ selectedPrefix: (t: string) => theme.fg('accent', t), selectedText: (t: string) => theme.fg('accent', t),
+  description: (t: string) => theme.fg('muted', t), scrollInfo: (t: string) => theme.fg('muted', t),
+  noMatch: () => theme.fg('muted', '  No matching models. Pi lists the models you are logged in to.') });
+
+/** Whole numbers only: typing replaces the value, Enter saves it, a bad value stays on screen with the reason. */
+class NumberStep extends Container {
+  private readonly input: Input;
+  private readonly error = new Text('', 0, 0);
+  constructor(theme: Theme, key: NumberKey, current: number, submit: (value: number) => string | undefined, cancel: () => void) {
+    super();
+    const spec = SETTINGS[key];
+    // Empty with the current value as placeholder: typing starts a new value, Enter alone keeps the old one.
+    this.input = new Input({ placeholder: String(current), placeholderStyle: text => theme.fg('dim', text) }); this.input.focused = true;
+    this.input.onEscape = cancel;
+    this.input.onSubmit = text => {
+      if (!text.trim()) return cancel();
+      const value = /^\s*\d+\s*$/.test(text) ? Number(text) : NaN;
+      const problem = invalid(key, value) ?? submit(value);
+      if (problem) this.error.setText(theme.fg('error', problem));
+    };
+    this.addChild(step(theme, `${spec.label}${spec.unit ? ` (${spec.unit})` : ''}`, `${spec.description} Default ${show(key, spec.default)}.`,
+      this.input, 'Type a number · Enter to save · Esc to go back', [this.error]));
+  }
+  handleInput(data: string) { this.input.handleInput(data); }
+}
+
+/** Model first (type to filter), then thinking level; Esc goes back a step. */
+class ModelStep extends Container {
+  private active: { handleInput(data: string): void } = { handleInput: () => {} };
+  constructor(private readonly theme: Theme, private readonly role: Role, private readonly models: string[], private readonly current: ModelChoice,
+    private readonly submit: (choice: ModelChoice) => string | undefined, private readonly cancel: () => void) {
+    super();
+    this.pickModel();
+  }
+  private pickModel() {
+    const { theme, current } = this, filter = new Input();
+    const items: SelectItem[] = this.models.map(value => ({ value, label: value }));
+    let list = new SelectList(items, 10, listTheme(theme));
+    const build = () => {
+      list = new SelectList(filter.getValue() ? fuzzyFilter(items, filter.getValue(), i => i.value) : items, 10, listTheme(theme));
+      list.onSelect = item => this.pickThinking(item.value); list.onCancel = this.cancel;
+      return list;
+    };
+    build(); list.setSelectedIndex(Math.max(0, this.models.indexOf(modelName(current))));
+    filter.focused = true;
+    const box = step(theme, ROLES[this.role].label, `${ROLES[this.role].description} Now ${showModel(current)}.`, filter, 'Type to filter · Enter to choose · Esc to go back', [new Spacer(1), list]);
+    this.show(box, data => {
+      const keys = getKeybindings();
+      if ((['tui.select.up', 'tui.select.down', 'tui.select.confirm', 'tui.select.cancel'] as const).some(k => keys.matches(data, k))) return list.handleInput(data);
+      filter.handleInput(data);
+      const index = box.children.indexOf(list); box.children[index] = build();
+    });
+  }
+  private pickThinking(model: string) {
+    const { theme, current } = this, error = new Text('', 0, 0);
+    const list = new SelectList(THINKING.map(value => ({ value, label: value })), THINKING.length, listTheme(theme));
+    list.setSelectedIndex(Math.max(0, THINKING.indexOf(current.thinking)));
+    list.onCancel = () => this.pickModel();
+    list.onSelect = item => {
+      const thinking = THINKING.find(level => level === item.value);
+      const slash = model.indexOf('/');
+      const problem = thinking && this.submit({ provider: model.slice(0, slash), model: model.slice(slash + 1), thinking });
+      if (problem) error.setText(theme.fg('error', problem));
+    };
+    this.show(step(theme, 'Thinking level', `For ${model}.`, list, 'Enter to save · Esc to go back', [error]), data => list.handleInput(data));
+  }
+  private show(box: Component, input: (data: string) => void) { this.clear(); this.addChild(box); this.active = { handleInput: input }; }
+  handleInput(data: string) { this.active.handleInput(data); }
+}
+
+/** The page itself: Pi's settings list over this profile's config, one row per setting, saved on change. */
+export function settingsPage(theme: Theme, o: Options, close: () => void, redraw = () => {}) {
+  const { config } = o;
+  const notice = new Text('', 2, 0);
+  const marker = (same: boolean, fallback: string) => theme.fg('dim', same ? '  default' : `  default ${fallback}`);
+  const value = (key: SettingKey, current: number | boolean) => `${show(key, current)}${marker(current === SETTINGS[key].default, show(key, SETTINGS[key].default))}`;
+  const apply = (patch: Partial<ProfileConfig>, what: string, applies: string) => {
+    try { o.save({ ...config, ...patch }); }
+    catch (error) { return `Could not save: ${error instanceof Error ? error.message : String(error)}`; }
+    Object.assign(config, patch);
+    notice.setText(theme.fg('success', `Saved ${what}. `) + theme.fg('muted', applies));
+    return undefined;
+  };
+  const models = (['compactor', 'subagent'] as const).map((role): SettingItem => {
+    const { label, description, applies } = ROLES[role];
+    return { id: role, label, description: `${description} Default ${showModel(defaults[role])}. ${applies}`,
+      currentValue: modelValue(theme, role, config[role]),
+      submenu: (_value, done) => new ModelStep(theme, role, o.models, config[role], choice => {
+        const problem = apply({ [role]: choice }, `${label.toLowerCase()} ${showModel(choice)}`, applies);
+        if (!problem) done(modelValue(theme, role, choice));
+        return problem;
+      }, () => done()),
+    };
+  });
+  const settings = SETTING_KEYS.map((key): SettingItem => {
+    const spec = SETTINGS[key], base = { id: key, label: spec.label, description: `${spec.description} ${spec.applies}` };
+    if (isNumberKey(key)) return { ...base, currentValue: value(key, config[key]),
+      submenu: (_value, done) => new NumberStep(theme, key, config[key], next => {
+        const problem = apply({ [key]: next }, `${spec.label.toLowerCase()} ${show(key, next)}`, spec.applies);
+        if (!problem) done(value(key, next));
+        return problem;
+      }, () => done()) };
+    return { ...base, currentValue: value(key, config[key]), values: [value(key, true), value(key, false)] };
+  });
+  const list = new SettingsList([...models, ...settings], 10, {
+    label: (text, selected) => selected ? theme.fg('accent', text) : text,
+    value: (text, selected) => selected ? theme.fg('accent', text) : theme.fg('muted', text),
+    description: text => theme.fg('dim', text), cursor: theme.fg('accent', '→ '), hint: text => theme.fg('dim', text),
+  }, (id, next) => {
+    // Only the on/off rows change here; the others save from their own step.
+    const key = SETTING_KEYS.find(k => k === id);
+    if (!key || isNumberKey(key)) return;
+    const on = next === value(key, true);
+    const problem = apply({ [key]: on }, `${SETTINGS[key].label.toLowerCase()} ${on ? 'on' : 'off'}`, SETTINGS[key].applies);
+    if (problem) { list.updateValue(key, value(key, config[key])); notice.setText(theme.fg('error', problem)); }
+  }, close);
+  const page = new Container();
+  for (const child of [new DynamicBorder(s => theme.fg('border', s)), new Text(`${theme.bold(theme.fg('accent', 'OptChat settings'))}${theme.fg('muted', ` · ${o.profile}`)}`, 1, 0),
+    new Text(theme.fg('dim', 'Saved as you change them · Victor\'s recipe by default, except Previous exchange and Summary size tolerance'), 1, 0),
+    new Spacer(1), list, notice, new DynamicBorder(s => theme.fg('border', s))]) page.addChild(child);
+  return Object.assign(page, { handleInput: (data: string) => { notice.setText(''); list.handleInput(data); redraw(); } });
+}
+
+export function showSettings(ctx: ExtensionContext, o: Options) {
+  return ctx.ui.custom<void>((tui, theme, _keys, done) => settingsPage(theme, o, () => done(undefined), () => tui.requestRender()));
+}

package/src/settings.ts

@@ -0,0 +1,42 @@
+import { NODE } from './memory.ts';
+
+/** Per-profile choices where OptChat departs from Victor's recipe. Each default is the recipe's behaviour unless noted. */
+export const SETTINGS = {
+  subagentLevels: { kind: 'number', label: 'Subagent levels', default: 1, min: 1, unit: '',
+    description: 'How many levels of subagents. 1: only the main agent starts subagents, as in Victor\'s recipe. 2: those subagents may start their own, and so on.',
+    applies: 'Applies to subagents started or resumed after this.' },
+  maxAgents: { kind: 'number', label: 'Max active agents', default: 8, min: 1, unit: '',
+    description: 'Subagents running at once in this profile, all levels together. It also caps how deep a chain can go.',
+    applies: 'Applies to the next spawn.' },
+  previousExchange: { kind: 'toggle', label: 'Previous exchange', default: true,
+    description: 'Send your last request and its answer in full with the next turn, so a follow-up reads the exact wording. Off: memory view only, as in Victor\'s recipe. On by default: a study found it costs little and saves zooms.',
+    applies: 'Applies from the next turn.' },
+  previousExchangeKB: { kind: 'number', label: 'Previous exchange limit', default: 16, min: 1, unit: 'KB',
+    description: 'A larger last exchange, usually a big paste, is left out and the model zooms into memory instead.',
+    applies: 'Applies from the next turn.' },
+  summaryAcceptBytes: { kind: 'number', label: 'Summary size tolerance', default: NODE * 1.25, min: NODE, unit: 'bytes',
+    description: `The compactor is always asked for ${NODE}-byte lines; a longer line up to this size is kept instead of retried. ${NODE}: strict, as in Victor's recipe. The default saves retries for a little more view space.`,
+    applies: 'Applies to the next summary.' },
+} as const;
+
+export type SettingKey = keyof typeof SETTINGS;
+export type Settings = { -readonly [K in SettingKey]: (typeof SETTINGS)[K]['default'] extends boolean ? boolean : number };
+export type NumberKey = { [K in SettingKey]: Settings[K] extends number ? K : never }[SettingKey];
+export const SETTING_KEYS = Object.keys(SETTINGS) as SettingKey[];
+export const isNumberKey = (key: SettingKey): key is NumberKey => SETTINGS[key].kind === 'number';
+
+/** Why a value can't be used, or undefined if it can. Numbers are whole and at least their minimum. */
+export function invalid(key: SettingKey, value: unknown) {
+  if (isNumberKey(key)) { const { label, min } = SETTINGS[key]; return Number.isSafeInteger(value) && Number(value) >= min ? undefined : `${label} must be a whole number of ${min} or more.`; }
+  return typeof value === 'boolean' ? undefined : `${SETTINGS[key].label} must be true or false.`;
+}
+
+/** Missing keys take their defaults, so config files written before a setting existed keep working. */
+export function readSettings(value: Record<string, unknown>): Settings {
+  return Object.fromEntries(SETTING_KEYS.map(key => {
+    const raw = Object.hasOwn(value, key) ? value[key] : SETTINGS[key].default, problem = invalid(key, raw);
+    if (problem) throw new Error(problem);
+    return [key, raw];
+  })) as Settings;
+}
+export const DEFAULT_SETTINGS = readSettings({});

package/src/transcript.ts

@@ -1,8 +1,9 @@
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
 import { getCurrentSystemMessage, type SystemMessage, type UserMessage } from '@earendil-works/pi-ai';
-import { cap, type Memory } from './memory.ts';
+import { CAP, cap, type Memory } from './memory.ts';
 import { record } from './cache.ts';
+import { DEFAULT_SETTINGS } from './settings.ts';
 
 export const RUN_BOUNDARY = 'optchat.run';
 /** Subagent traffic to the main agent: a custom message on screen, a plain user message to the model and memory. */
@@ -44,7 +45,7 @@ export function logMessage(memory: Memory, message: AgentMessage, receipt?: stri
 export function boundedMessage(message: AgentMessage): AgentMessage {
   if (message.role !== 'toolResult') return message;
   const text = message.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
-  if (text.length <= 30_000) return message;
+  if (text.length <= CAP) return message;
   return { ...message, content: [{ type: 'text', text: cap(text) }, ...message.content.filter(c => c.type === 'image')] };
 }
 /** The caller supplies a single settled run, including any steering after text-only replies. */
@@ -63,8 +64,18 @@ function completedExchange(history: readonly AgentMessage[]) {
   return [...requests, { ...answer, content }];
 }
 
-/** Recover the latest successful run on this branch, skipping failed and unfinished runs. */
-export function previousExchange(branch: readonly SessionEntry[]) {
+/** Default limit in bytes of text (16 KB, ~4,000 tokens). Most exchanges are 1-7 KB; a larger one, usually a big paste, is
+ * left out entirely and the model falls back to its summaries in the memory view, zooming for the full text if it needs it. */
+export const PREVIOUS_EXCHANGE = DEFAULT_SETTINGS.previousExchangeKB * 1000;
+
+/** The latest successful run on this branch, skipping failed and unfinished runs; none if it is over `limit` bytes. */
+export function previousExchange(branch: readonly SessionEntry[], limit = PREVIOUS_EXCHANGE) {
+  const exchange = latestExchange(branch);
+  const bytes = exchange.reduce((sum, message) => sum + Buffer.byteLength(textContent(message.content)), 0);
+  return bytes <= limit ? exchange : [];
+}
+
+function latestExchange(branch: readonly SessionEntry[]) {
   let end = -1;
   let legacyEnd = branch.length;
   const messages = (entries: readonly SessionEntry[]) => entries.flatMap(entry => entry.type === 'message' ? [asUser(entry.message)] : entry.type === 'custom_message' && entry.customType === REPORT_TYPE ? [asUser({ role: 'custom', customType: entry.customType, content: entry.content, display: entry.display, timestamp: Date.parse(entry.timestamp) })] : []);

package/src/usage.ts

@@ -36,27 +36,27 @@ export function addUsage(total: Usage, usage: Usage) {
 /** One profile's ledger. Stable message IDs make resume/backfill idempotent. */
 export class UsageLedger {
   readonly entries: UsageEntry[] = [];
-  readonly warnings: string[] = [];
+  private invalid = 0;
   private readonly ids = new Set<string>();
   private readonly cursors = new Map<string, number>();
   private readonly file: string;
   constructor(directory: string) {
     this.file = join(directory, 'usage.jsonl');
-    let invalid = 0;
     const contents = existsSync(this.file) ? readFileSync(this.file, 'utf8') : '';
     for (const line of contents.split('\n')) {
       if (!line.trim()) continue;
       try {
         const entry: unknown = JSON.parse(line);
-        if (!validEntry(entry)) { invalid++; continue; }
+        if (!validEntry(entry)) { this.invalid++; continue; }
         if (entry.id && this.ids.has(entry.id)) continue;
         this.entries.push(entry); if (entry.id) this.ids.add(entry.id);
-      } catch { invalid++; }
+      } catch { this.invalid++; }
     }
-    if (invalid) this.warnings.push(`${invalid} unreadable usage records excluded; totals may be incomplete.`);
     if (contents && !contents.endsWith('\n')) appendFileSync(this.file, '\n');
   }
+  get warnings() { return this.invalid ? [`${this.invalid} unreadable usage records excluded; totals may be incomplete.`] : []; }
   add(entry: UsageEntry) {
+    if (!validEntry(entry)) { this.invalid++; return; }
     if (entry.id && this.ids.has(entry.id)) return;
     appendJson(this.file, entry);
     this.entries.push(entry); if (entry.id) this.ids.add(entry.id);
@@ -86,18 +86,18 @@ export class UsageLedger {
   select(range: UsageRange, session: string, now = Date.now()) {
     const today = new Date(now); today.setHours(0, 0, 0, 0);
     const since = range === 'Last hour' ? now - 3600_000 : range === 'Today' ? today.getTime() : range === 'Last 7 days' ? now - 7 * 86400_000 : 0;
-    return this.entries.filter(e => range === 'This session' ? e.session === session : Date.parse(e.date) >= since && Date.parse(e.date) <= now);
+    return this.entries.filter(e => range === 'This session' ? e.session === session : range === 'All time' || (Date.parse(e.date) >= since && Date.parse(e.date) <= now));
   }
 }
 
 export function summarizeUsage(entries: UsageEntry[]) {
-  const total = emptyUsage(), groups = new Map<string, { role: UsageRole; model: string; requests: number; usage: Usage }>();
+  const total = emptyUsage(), groups = new Map<string, { role: UsageRole; model: string; usage: Usage }>();
   for (const entry of entries) {
-    const model = entry.provider ? `${entry.provider}/${entry.model}` : entry.model;
-    const key = `${entry.role}:${model}`;
+    // By model name alone: older compactor records lack a provider and must still land in the same row.
+    const key = `${entry.role}:${entry.model}`;
     let group = groups.get(key);
-    if (!group) { group = { role: entry.role, model, requests: 0, usage: emptyUsage() }; groups.set(key, group); }
-    group.requests++; addUsage(group.usage, entry.usage); addUsage(total, entry.usage);
+    if (!group) { group = { role: entry.role, model: entry.model, usage: emptyUsage() }; groups.set(key, group); }
+    addUsage(group.usage, entry.usage); addUsage(total, entry.usage);
   }
   return { total, groups: [...groups.values()] };
 }

package/src/window-bridge.ts

@@ -1,9 +1,9 @@
-import { chmodSync, existsSync, unlinkSync } from 'node:fs';
+import { chmodSync } from 'node:fs';
 import { createConnection, createServer, type Socket } from 'node:net';
 import type { Children } from './agents.ts';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { record } from './cache.ts';
-import { profileSocket } from './profiles.ts';
+import { checkSocketPath, profileSocket, removeStaleSocket } from './profiles.ts';
 import { textContent } from './transcript.ts';
 import { isActiveRun } from './runs.ts';
 
@@ -83,8 +83,8 @@ function wire(socket: Socket, receive: (frame: Frame) => void) {
 /** Call only while holding the profile lock. The owner hosts every child session. */
 export async function serveWindows(directory: string, children: Children, available: () => boolean,
   report: (text: string) => Promise<void>) {
-  const path = profileSocket(directory, 'windows');
-  if (existsSync(path)) unlinkSync(path); // A previous owner can no longer hold the profile lock.
+  const path = profileSocket(directory, 'windows'); checkSocketPath(path);
+  removeStaleSocket(path); // A previous owner can no longer hold the profile lock.
   const connections = new Set<Socket>();
   const work = new Set<Promise<void>>();
   let closing = false;