@superjackfruitlabs/salaam 0.0.4 → 0.0.5

package/src/tui-commands.ts

@@ -17,15 +17,11 @@ export const SLASH_COMMANDS: readonly SlashDefinition[] = [
   command('help', 'Show commands and their execution type', ['commands'], '[command]'),
   command('exit', 'Detach; preserve the session and running work', ['quit', 'q']),
   command('keys', 'Show keyboard shortcuts', ['hotkeys']),
-  command('model', 'Choose provider and model for a new session', ['models'], '[provider/model]'),
-  command('provider', 'Choose a provider for a new session', [], '[provider]'),
-  command('thinking', 'Choose reasoning effort for a new session', [], '[level]'),
-  command(
-    'coding',
-    'New local coding session with reviewed edits and unsandboxed commands',
-    [],
-    '[workspace]',
-  ),
+  command('model', 'Switch this session’s provider and model', ['models'], '[provider/model]'),
+  command('provider', 'Switch this session’s provider', [], '[provider]'),
+  command('thinking', 'Switch this session’s reasoning effort', [], '[level]'),
+  command('coding', 'New local coding session with reviewed edits and commands', [], '[workspace]'),
+  command('init', 'Draft an AGENTS.md for this repository; the edit asks for approval'),
   command('new', 'Create a session in a workspace', [], '[workspace]'),
   command('sessions', 'Switch or resume a session', ['resume'], '[session-id]'),
   command('name', 'Set a durable session label', ['rename'], '<name>'),
@@ -39,9 +35,30 @@ export const SLASH_COMMANDS: readonly SlashDefinition[] = [
     [],
     '<text>',
   ),
-  command('diff', 'Review workspace changes'),
+  command('diff', 'Review workspace changes file by file'),
+  command(
+    'commit',
+    'Draft a commit of the current work; staging and the commit each ask (uses provider credits)',
+    [],
+    undefined,
+    'model',
+  ),
+  command('branch', 'Switch to a branch, creating it if needed', [], '<name>', 'model'),
+  command(
+    'pr',
+    'Push this branch and open a pull request; both always ask, except in YOLO',
+    [],
+    '[base]',
+    'model',
+  ),
   command('tools', 'Inspect available capabilities and recorded tool activity'),
   command('permissions', 'Configure local permissions independently of task progression'),
+  command('mode', 'Cycle review → accept edits → auto (shift+tab)'),
+  command(
+    'full-access',
+    'Turn full access on or off: commands run without the OS sandbox; dangerous ones still ask',
+  ),
+  command('yolo', 'Turn YOLO on (type yolo to confirm) or off: no sandbox and no approvals'),
   command('approvals', 'Review exact pending approval requests'),
   command('context', 'Inspect session context, facts and usage'),
   command('usage', 'Show recorded usage and unknown observations'),
@@ -50,6 +67,7 @@ export const SLASH_COMMANDS: readonly SlashDefinition[] = [
   command('export', 'Export full durable conversation as Markdown; never overwrite', [], '[path]'),
   command('settings', 'Choose terminal appearance and model settings'),
   command('fork', 'Fork an idle local conversation; keep the same workspace'),
+  command('rewind', 'Rewind files, conversation or both to before an earlier turn', [], '[turn]'),
   command(
     'undo',
     'Review and revert the last completed local edit; retain conversation history',
@@ -80,6 +98,19 @@ export const SLASH_COMMANDS: readonly SlashDefinition[] = [
   command('agents', 'Inspect native/external worker profiles and child work'),
   command('progression', 'Choose manual or bounded task progression; permissions stay separate'),
   command('tasks', 'Open durable task actions'),
+  command(
+    'classifier',
+    'Pick the small-model command reviewer for this session, or turn it off',
+    [],
+    '[name|on|off]',
+  ),
+  command(
+    'hooks',
+    'Show your hooks and this workspace’s; trust or revoke the workspace file',
+    [],
+    '[trust|revoke]',
+  ),
+  command('jobs', 'Show background commands and their output, or stop one', ['bg'], '[stop <id>]'),
 ];
 export const SLASH_COMPLETIONS = SLASH_COMMANDS.flatMap((c) =>
   [c.name, ...c.aliases].map((name) => ({ name, description: c.description })),
@@ -125,3 +156,11 @@ export function slashHelp(name?: string): string {
     )
     .join('\n');
 }
+
+/** What /init asks the agent to do. The write goes through the session's normal edit approval. */
+export const INIT_INSTRUCTION = [
+  'Draft an AGENTS.md for this repository.',
+  'First read the tree and the files that define how it is built and tested (package manifests, build and CI configuration, README, existing contributor docs, any CLAUDE.md).',
+  'Then write AGENTS.md at the repository root: a short overview, the exact commands to build, test, lint and format, the code layout, and conventions a contributor must follow.',
+  'Keep it under 150 lines, state only what the files show, and if AGENTS.md already exists, propose improvements to it instead of replacing it.',
+].join(' ');

package/src/tui-composer.ts

@@ -0,0 +1,124 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+/**
+ * Composer behaviour for the trial-polish batch (operator approval 2026-10-31): Ctrl+C in steps,
+ * reverse history search, persisted history that never keeps secret-looking lines, and `!command`.
+ */
+
+/** What Ctrl+C does now: stop a running turn, else clear typed text, else arm, else leave. */
+export type CtrlCAction = 'interrupt' | 'clear' | 'arm' | 'exit';
+export const CTRL_C_WINDOW_MS = 2000;
+
+export function ctrlCAction(input: {
+  running: boolean;
+  text: string;
+  armedAt: number | undefined;
+  now: number;
+}): CtrlCAction {
+  if (input.running) return 'interrupt';
+  if (input.text !== '') return 'clear';
+  if (input.armedAt !== undefined && input.now - input.armedAt <= CTRL_C_WINDOW_MS) return 'exit';
+  return 'arm';
+}
+
+const SECRET_PATTERNS: RegExp[] = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+  /\b(sk|rk|pk)-[A-Za-z0-9_-]{16,}/,
+  /\bsk-ant-[A-Za-z0-9_-]{8,}/,
+  /\bgh[pousr]_[A-Za-z0-9]{20,}/,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}/,
+  /\bxox[abprs]-[A-Za-z0-9-]{10,}/,
+  /\bAKIA[0-9A-Z]{16}\b/,
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\./,
+  /\b(password|passwd|secret|token|api[_-]?key|authorization)\s*[:=]\s*\S{6,}/i,
+  /\bbearer\s+[A-Za-z0-9._~+/-]{16,}/i,
+  /[A-Za-z0-9+_-]{48,}={0,2}/,
+];
+
+/** True when the text looks like it carries a credential; such text is never written to history. */
+export function looksSecret(text: string): boolean {
+  return SECRET_PATTERNS.some((p) => p.test(text));
+}
+
+export const HISTORY_LIMIT = 500;
+export const HISTORY_ENTRY_LIMIT = 8192;
+
+/** Where this user's composer history lives: $XDG_STATE_HOME/salaam/history.json, or nowhere when
+ * SALAAM_HISTORY=off (history then lasts only for this terminal). */
+export function historyPath(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  if (env.SALAAM_HISTORY === 'off') return undefined;
+  const base = env.XDG_STATE_HOME || join(env.HOME || homedir(), '.local', 'state');
+  return join(base, 'salaam', 'history.json');
+}
+
+/** Per-user composer history, newest last, bounded, and without secret-looking entries. */
+export class ComposerHistory {
+  entries: string[] = [];
+  constructor(private readonly path: string | undefined) {
+    try {
+      if (path && existsSync(path)) {
+        const raw: unknown = JSON.parse(readFileSync(path, 'utf8'));
+        if (Array.isArray(raw))
+          this.entries = raw
+            .filter((e): e is string => typeof e === 'string')
+            .filter((e) => keepable(e))
+            .slice(-HISTORY_LIMIT);
+      }
+    } catch {
+      this.entries = [];
+    }
+  }
+  /** Adds a sent message. Returns false when it was not kept (blank, too long, or secret-looking). */
+  add(text: string): boolean {
+    if (!keepable(text)) return false;
+    this.entries = this.entries.filter((e) => e !== text);
+    this.entries.push(text);
+    if (this.entries.length > HISTORY_LIMIT) this.entries = this.entries.slice(-HISTORY_LIMIT);
+    this.save();
+    return true;
+  }
+  private save(): void {
+    if (!this.path) return;
+    try {
+      mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+      const tmp = this.path + '.tmp';
+      writeFileSync(tmp, JSON.stringify(this.entries), { mode: 0o600 });
+      chmodSync(tmp, 0o600);
+      renameSync(tmp, this.path);
+    } catch {
+      // History is a convenience; failing to save never blocks sending.
+    }
+  }
+}
+
+function keepable(text: string): boolean {
+  return text.trim() !== '' && text.length <= HISTORY_ENTRY_LIMIT && !looksSecret(text);
+}
+
+/**
+ * Reverse-incremental search: the newest entry older than `before` (an index into `entries`,
+ * newest last) that contains the query, case-insensitively. Returns its index or -1.
+ */
+export function searchHistory(entries: string[], query: string, before: number): number {
+  const q = query.toLowerCase();
+  for (let i = Math.min(before, entries.length) - 1; i >= 0; i--)
+    if (entries[i]!.toLowerCase().includes(q)) return i;
+  return -1;
+}
+
+/** The status-line text while searching, matching readline's wording. */
+export function searchPrompt(query: string, match: string | undefined): string {
+  const shown = match === undefined ? '' : match.replace(/\s+/g, ' ').slice(0, 120);
+  return match === undefined && query !== ''
+    ? `(failing reverse-i-search)\`${query}': · esc cancels`
+    : `(reverse-i-search)\`${query}': ${shown} · enter keeps · ctrl+r older · esc cancels`;
+}
+
+/**
+ * `!command` from the composer. The TUI never runs it itself: it becomes an instruction for the
+ * model to run exactly this command through salaam_local, so it takes the same approval path,
+ * session mode, sandbox and danger check as any model command. Returns undefined for other text.
+ */
+export { shellPassthrough } from './shell-passthrough.js';

package/src/tui-keymap.ts

@@ -0,0 +1,152 @@
+import type { KeyId } from '@earendil-works/pi-tui';
+
+/**
+ * The TUI's keys in one table (trial polish C, 2026-10-31). The global bindings in tui.ts and the
+ * `?` key sheet both read this, so the sheet cannot drift from what the keys do.
+ */
+export type GlobalAction =
+  | 'palette'
+  | 'sessions'
+  | 'new'
+  | 'approvals'
+  | 'changes'
+  | 'commands'
+  | 'rail'
+  | 'transcript'
+  | 'refresh'
+  | 'editor'
+  | 'mode'
+  | 'help';
+
+export const GLOBAL_KEYS: readonly { key: KeyId; action: GlobalAction; label: string }[] = [
+  { key: 'ctrl+k', action: 'palette', label: 'all actions' },
+  { key: 'f2', action: 'palette', label: 'all actions' },
+  { key: 'ctrl+p', action: 'sessions', label: 'sessions' },
+  { key: 'ctrl+n', action: 'new', label: 'new session' },
+  { key: 'ctrl+o', action: 'approvals', label: 'approvals' },
+  { key: 'alt+g', action: 'changes', label: 'changes' },
+  { key: 'ctrl+t', action: 'commands', label: 'commands' },
+  { key: 'ctrl+b', action: 'rail', label: 'show or hide the side panel' },
+  { key: 'ctrl+x', action: 'transcript', label: 'full transcript on or off' },
+  { key: 'f5', action: 'refresh', label: 'refresh' },
+  { key: 'ctrl+g', action: 'editor', label: 'external prompt editor' },
+  { key: 'shift+tab', action: 'mode', label: 'next mode' },
+  { key: 'f1', action: 'help', label: 'these keys' },
+];
+
+/** The per-file review on the Changes tab of a desk session. */
+export const REVIEW_KEYS = {
+  nextFile: { key: 'alt+right', label: 'next file' },
+  previousFile: { key: 'alt+left', label: 'previous file' },
+  nextHunk: { key: 'alt+down', label: 'next hunk' },
+  previousHunk: { key: 'alt+up', label: 'previous hunk' },
+  accept: { key: 'a', label: 'accept the file or hunk' },
+  revert: { key: 'r', label: 'revert it (asks first)' },
+  instruct: { key: 'i', label: 'tell the model about it' },
+} as const;
+
+/** Keys while a desk turn runs (tui-turn-keys.ts decides them). */
+export const TURN_KEYS = [
+  { key: 'escape', label: 'stop the turn' },
+  { key: 'enter', label: 'steer it' },
+  { key: 'tab', label: 'queue for after' },
+] as const;
+
+const COMPOSER: { label: string; description?: string }[] = [
+  { label: 'Enter · send', description: 'The durable outbox saves it before delivery' },
+  { label: 'Alt+Enter / Ctrl+J · new line' },
+  { label: 'Tab · switch view', description: 'Conversation · Changes · Commands · Context' },
+  { label: 'PageUp / PageDown · scroll', description: 'Ctrl+Home/End jump to the top/bottom' },
+  { label: '@ · attach a file or image' },
+  { label: '/ · slash commands' },
+  {
+    label: 'Ctrl+R · search sent messages',
+    description: 'Ctrl+R for older, Enter keeps, Esc restores',
+  },
+  {
+    label: 'Ctrl+A/E · Ctrl+U/K/W · Ctrl+Y · Ctrl+-',
+    description: 'Line start/end, kill to start/end/word, yank, undo; Alt+B/F words',
+  },
+  {
+    label: '!command · run a shell command',
+    description: 'Same approval, sandbox and danger check',
+  },
+  {
+    label: 'Ctrl+C · stop, clear, then leave',
+    description: 'Stops a running turn, else clears text; twice on empty leaves. Work continues.',
+  },
+];
+const CODING_COMMANDS = [
+  { label: '/rewind · go back to an earlier turn' },
+  { label: '/jobs · background commands' },
+  { label: '/undo · revert the last edit' },
+];
+
+export function keyLabel(key: string): string {
+  const names: Record<string, string> = { escape: 'Esc', enter: 'Enter', tab: 'Tab' };
+  if (names[key]) return names[key];
+  if (key.length === 1) return key;
+  return key
+    .split('+')
+    .map((part) =>
+      part === 'right'
+        ? '→'
+        : part === 'left'
+          ? '←'
+          : part === 'up'
+            ? '↑'
+            : part === 'down'
+              ? '↓'
+              : part.length <= 2
+                ? part.toUpperCase()
+                : part[0]!.toUpperCase() + part.slice(1),
+    )
+    .join('+');
+}
+
+export interface KeyContext {
+  tab: string;
+  coding: boolean;
+  running: boolean;
+  /** Your own slash commands (Phase 4b), listed in the conversation sheet. */
+  custom?: readonly { name: string; description: string; argumentHint?: string }[];
+}
+
+export function keySheet(c: KeyContext): {
+  title: string;
+  rows: { label: string; description?: string }[];
+} {
+  const global = GLOBAL_KEYS.map((k) => ({ label: keyLabel(k.key) + ' · ' + k.label }));
+  const approvals = { label: 'Approvals show their own keys along the bottom' };
+  if (c.tab === 'changes' && c.coding)
+    return {
+      title: 'Keys · Review changes',
+      rows: [
+        ...Object.values(REVIEW_KEYS).map((k) => ({ label: keyLabel(k.key) + ' · ' + k.label })),
+        { label: 'a, r and i work while the composer is empty' },
+        ...global,
+      ],
+    };
+  if (c.coding && c.running)
+    return {
+      title: 'Keys · Turn running',
+      rows: [
+        ...TURN_KEYS.map((k) => ({ label: keyLabel(k.key) + ' · ' + k.label })),
+        ...global,
+        approvals,
+      ],
+    };
+  return {
+    title: 'Keys · Conversation',
+    rows: [
+      ...COMPOSER,
+      ...(c.coding ? CODING_COMMANDS : []),
+      ...(c.custom ?? []).map((k) => ({
+        label: `/${k.name}${k.argumentHint ? ' ' + k.argumentHint : ''} · your command`,
+        description: k.description,
+      })),
+      ...global,
+      approvals,
+    ],
+  };
+}

package/src/tui-mentions.ts

@@ -0,0 +1,43 @@
+import { CombinedAutocompleteProvider } from '@earendil-works/pi-tui';
+import { basename } from 'node:path';
+import { listWorkspaceFiles, rankFiles } from './mentions.js';
+
+/**
+ * `@` completes workspace files from git's own listing (ignored files stay out) instead of
+ * pi-tui's `fd` walk, which is absent on most desks. The listing is cached for 5 s.
+ */
+export class MentionAutocompleteProvider extends CombinedAutocompleteProvider {
+  private cache?: { at: number; files: string[] };
+  constructor(
+    commands: ConstructorParameters<typeof CombinedAutocompleteProvider>[0],
+    private readonly root: string,
+  ) {
+    super(commands, root, null);
+  }
+  files(): string[] {
+    if (!this.cache || Date.now() - this.cache.at > 5000)
+      this.cache = { at: Date.now(), files: listWorkspaceFiles(this.root) };
+    return this.cache.files;
+  }
+  override async getSuggestions(
+    lines: string[],
+    cursorLine: number,
+    cursorCol: number,
+    options: { signal: AbortSignal; force?: boolean },
+  ): ReturnType<CombinedAutocompleteProvider['getSuggestions']> {
+    const before = (lines[cursorLine] ?? '').slice(0, cursorCol);
+    const match = /(?:^|[\s([{])(@"[^"]*|@[^\s"]*)$/.exec(before);
+    if (!match) return super.getSuggestions(lines, cursorLine, cursorCol, options);
+    if (options.signal.aborted) return null;
+    const prefix = match[1]!;
+    const quoted = prefix.startsWith('@"');
+    const items = rankFiles(this.files(), prefix.slice(quoted ? 2 : 1))
+      .slice(0, 20)
+      .map((file) => ({
+        value: quoted || /\s/.test(file) ? `@"${file}"` : `@${file}`,
+        label: basename(file),
+        description: file,
+      }));
+    return items.length ? { items, prefix } : null;
+  }
+}