@rmrdeveloper/sideroom-pi 5.0.1 → 6.0.1

package/extensions/ask/ui.ts

@@ -0,0 +1,445 @@
+import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+import {
+  Editor,
+  type EditorTheme,
+  Key,
+  matchesKey,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from '@earendil-works/pi-tui';
+import {
+  type AskAnswer,
+  type AskQuestion,
+  type AskResult,
+  type RenderOption,
+  renderOptions,
+} from './model.ts';
+
+export async function runAskUi(
+  ui: Pick<ExtensionUIContext, 'custom'>,
+  questions: readonly AskQuestion[],
+): Promise<AskResult> {
+  const isMulti = questions.length > 1;
+  const totalTabs = questions.length + 1;
+
+  return ui.custom<AskResult>((tui, theme, _keybindings, done) => {
+    let currentTab = 0;
+    const firstQuestion = questions[0];
+    let optionIndex =
+      firstQuestion === undefined ? 0 : firstQuestion.recommendationIndex;
+    let inputMode = false;
+    let inputQuestionId: string | null = null;
+    let cachedLines: string[] | undefined;
+    const answers = new Map<string, AskAnswer>();
+
+    const editorTheme: EditorTheme = {
+      borderColor: (s) => theme.fg('accent', s),
+      selectList: {
+        selectedPrefix: (t) => theme.fg('accent', t),
+        selectedText: (t) => theme.fg('accent', t),
+        description: (t) => theme.fg('muted', t),
+        scrollInfo: (t) => theme.fg('dim', t),
+        noMatch: (t) => theme.fg('warning', t),
+      },
+    };
+    const editor = new Editor(tui, editorTheme);
+
+    function refresh(): void {
+      cachedLines = undefined;
+      tui.requestRender();
+    }
+
+    function submit(cancelled: boolean): void {
+      done({
+        questions,
+        answers: Array.from(answers.values()),
+        cancelled,
+      });
+    }
+
+    function currentQuestion(): AskQuestion | undefined {
+      return questions[currentTab];
+    }
+
+    function currentOptions(): RenderOption[] {
+      const question = currentQuestion();
+      if (question === undefined) {
+        return [];
+      }
+      return renderOptions(question);
+    }
+
+    function allAnswered(): boolean {
+      return questions.every((question) => answers.has(question.id));
+    }
+
+    function focusTab(tab: number): void {
+      currentTab = tab;
+      const question = questions[tab];
+      if (question === undefined) {
+        optionIndex = 0;
+        refresh();
+        return;
+      }
+      const saved = answers.get(question.id);
+      if (saved?.index !== undefined) {
+        optionIndex = saved.index - 1;
+      } else {
+        optionIndex = question.recommendationIndex;
+      }
+      refresh();
+    }
+
+    function advanceAfterAnswer(): void {
+      if (!isMulti) {
+        submit(false);
+        return;
+      }
+      if (currentTab < questions.length - 1) {
+        focusTab(currentTab + 1);
+        return;
+      }
+      focusTab(questions.length);
+    }
+
+    function saveAnswer(answer: AskAnswer): void {
+      answers.set(answer.id, answer);
+    }
+
+    function openCustomEditor(question: AskQuestion): void {
+      inputMode = true;
+      inputQuestionId = question.id;
+      const saved = answers.get(question.id);
+      if (saved?.wasCustom === true) {
+        editor.setText(saved.label);
+      } else {
+        editor.setText('');
+      }
+      refresh();
+    }
+
+    function confirmOption(
+      question: AskQuestion,
+      opts: readonly RenderOption[],
+      index: number,
+    ): void {
+      const opt = opts[index];
+      if (opt === undefined) {
+        return;
+      }
+      if (opt.isOther === true) {
+        openCustomEditor(question);
+        return;
+      }
+      if (opt.isOutOfScope === true) {
+        saveAnswer({
+          id: question.id,
+          value: opt.value,
+          label: opt.label,
+          wasCustom: false,
+          outOfScope: true,
+          index: index + 1,
+        });
+        advanceAfterAnswer();
+        return;
+      }
+      const original = question.options[index];
+      saveAnswer({
+        id: question.id,
+        value: original?.value ?? opt.value,
+        label: original?.label ?? opt.label,
+        wasCustom: false,
+        outOfScope: false,
+        index: index + 1,
+      });
+      advanceAfterAnswer();
+    }
+
+    editor.onSubmit = (value) => {
+      if (inputQuestionId === null) {
+        return;
+      }
+      const trimmed = value.trim();
+      if (trimmed.length === 0) {
+        inputMode = false;
+        inputQuestionId = null;
+        editor.setText('');
+        refresh();
+        return;
+      }
+      const question = questions.find((entry) => entry.id === inputQuestionId);
+      const displayIndex =
+        question === undefined ? 1 : renderOptions(question).length;
+      saveAnswer({
+        id: inputQuestionId,
+        value: trimmed,
+        label: trimmed,
+        wasCustom: true,
+        outOfScope: false,
+        index: displayIndex,
+      });
+      inputMode = false;
+      inputQuestionId = null;
+      editor.setText('');
+      advanceAfterAnswer();
+    };
+
+    function handleInput(data: string): void {
+      if (inputMode) {
+        if (matchesKey(data, Key.escape)) {
+          inputMode = false;
+          inputQuestionId = null;
+          editor.setText('');
+          refresh();
+          return;
+        }
+        editor.handleInput(data);
+        refresh();
+        return;
+      }
+
+      const question = currentQuestion();
+      const opts = currentOptions();
+
+      if (isMulti) {
+        if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
+          focusTab((currentTab + 1) % totalTabs);
+          return;
+        }
+        if (matchesKey(data, Key.shift('tab')) || matchesKey(data, Key.left)) {
+          focusTab((currentTab - 1 + totalTabs) % totalTabs);
+          return;
+        }
+      }
+
+      if (currentTab === questions.length) {
+        if (matchesKey(data, Key.enter) && allAnswered()) {
+          submit(false);
+        } else if (matchesKey(data, Key.escape)) {
+          submit(true);
+        }
+        return;
+      }
+
+      if (matchesKey(data, Key.up)) {
+        optionIndex = Math.max(0, optionIndex - 1);
+        refresh();
+        return;
+      }
+      if (matchesKey(data, Key.down)) {
+        optionIndex = Math.min(opts.length - 1, optionIndex + 1);
+        refresh();
+        return;
+      }
+
+      const digit = optionIndexFromDigit(data, opts.length);
+      if (digit !== undefined && question !== undefined) {
+        optionIndex = digit;
+        confirmOption(question, opts, digit);
+        return;
+      }
+
+      if (matchesKey(data, Key.enter) && question !== undefined) {
+        confirmOption(question, opts, optionIndex);
+        return;
+      }
+
+      if (matchesKey(data, Key.escape)) {
+        submit(true);
+      }
+    }
+
+    function render(width: number): string[] {
+      if (cachedLines !== undefined) {
+        return cachedLines;
+      }
+
+      const lines: string[] = [];
+      const renderWidth = Math.max(1, width);
+      const question = currentQuestion();
+      const opts = currentOptions();
+
+      function addWrapped(text: string): void {
+        lines.push(...wrapTextWithAnsi(text, renderWidth));
+      }
+
+      function addWrappedWithPrefix(prefix: string, text: string): void {
+        const prefixWidth = visibleWidth(prefix);
+        if (prefixWidth >= renderWidth) {
+          addWrapped(prefix + text);
+          return;
+        }
+        const wrapped = wrapTextWithAnsi(text, renderWidth - prefixWidth);
+        const continuationPrefix = ' '.repeat(prefixWidth);
+        for (let index = 0; index < wrapped.length; index += 1) {
+          const part = wrapped[index];
+          if (part === undefined) {
+            continue;
+          }
+          lines.push(`${index === 0 ? prefix : continuationPrefix}${part}`);
+        }
+      }
+
+      lines.push(theme.fg('accent', '─'.repeat(renderWidth)));
+
+      if (isMulti) {
+        const tabs: string[] = [];
+        for (let index = 0; index < questions.length; index += 1) {
+          const entry = questions[index];
+          if (entry === undefined) {
+            continue;
+          }
+          const isActive = index === currentTab;
+          const isAnswered = answers.has(entry.id);
+          const mark = isAnswered ? '●' : '○';
+          const color = isAnswered ? 'success' : 'muted';
+          const text = ` ${mark} ${entry.label} `;
+          const styled = isActive
+            ? theme.bg('selectedBg', theme.fg('text', text))
+            : theme.fg(color, text);
+          tabs.push(styled);
+        }
+        const canSubmit = allAnswered();
+        const isSubmitTab = currentTab === questions.length;
+        const submitText = ' Submit ';
+        const submitStyled = isSubmitTab
+          ? theme.bg('selectedBg', theme.fg('text', submitText))
+          : theme.fg(canSubmit ? 'success' : 'dim', submitText);
+        tabs.push(submitStyled);
+        addWrappedWithPrefix(' ', tabs.join(' '));
+        lines.push('');
+      }
+
+      function renderOptionList(): void {
+        for (let index = 0; index < opts.length; index += 1) {
+          const opt = opts[index];
+          if (opt === undefined) {
+            continue;
+          }
+          if (opt.isOutOfScope === true) {
+            lines.push('');
+          }
+          const selected = index === optionIndex;
+          const prefix = selected ? theme.fg('accent', '> ') : '  ';
+          const color = selected ? 'accent' : 'text';
+          let line = theme.fg(color, `${String(index + 1)}. ${opt.label}`);
+          if (opt.isRecommended === true) {
+            line = `${line} ${theme.fg('dim', 'recommended')}`;
+          }
+          addWrappedWithPrefix(prefix, line);
+          if (opt.description !== undefined) {
+            addWrappedWithPrefix('     ', theme.fg('muted', opt.description));
+          }
+        }
+      }
+
+      if (inputMode && question !== undefined) {
+        addWrappedWithPrefix(
+          ' ',
+          theme.fg('accent', theme.bold(question.prompt)),
+        );
+        lines.push('');
+        addWrappedWithPrefix(' ', theme.fg('muted', 'Custom answer'));
+        for (const line of editor.render(Math.max(1, renderWidth - 2))) {
+          lines.push(` ${line}`);
+        }
+        lines.push('');
+        addWrappedWithPrefix(
+          ' ',
+          theme.fg('dim', 'Enter save · Esc back to options'),
+        );
+      } else if (currentTab === questions.length) {
+        for (const entry of questions) {
+          const answer = answers.get(entry.id);
+          const name = theme.fg('muted', `${entry.label}: `);
+          if (answer === undefined) {
+            addWrappedWithPrefix(
+              ' ',
+              `${name}${theme.fg('warning', 'not answered')}`,
+            );
+            continue;
+          }
+          let kind = '';
+          if (answer.outOfScope) {
+            kind = 'out of scope · ';
+          } else if (answer.wasCustom) {
+            kind = 'custom · ';
+          }
+          addWrappedWithPrefix(
+            ' ',
+            `${name}${theme.fg('dim', kind)}${theme.fg('text', answer.label)}`,
+          );
+        }
+        lines.push('');
+        if (allAnswered()) {
+          addWrappedWithPrefix(
+            ' ',
+            theme.fg('success', 'Enter send answers · Esc cancel'),
+          );
+        } else {
+          const missing = questions
+            .filter((entry) => !answers.has(entry.id))
+            .map((entry) => entry.label)
+            .join(', ');
+          addWrappedWithPrefix(
+            ' ',
+            theme.fg('warning', `Answer ${missing} to continue`),
+          );
+        }
+      } else if (question !== undefined) {
+        addWrappedWithPrefix(
+          ' ',
+          theme.fg('accent', theme.bold(question.prompt)),
+        );
+        const saved = answers.get(question.id);
+        if (saved !== undefined) {
+          addWrappedWithPrefix(
+            ' ',
+            theme.fg('muted', `Current: ${saved.label}`),
+          );
+        }
+        lines.push('');
+        renderOptionList();
+      }
+
+      if (!inputMode && currentTab !== questions.length) {
+        lines.push('');
+        const count = String(opts.length);
+        const help = isMulti
+          ? `↑↓ or 1–${count} · Enter · Tab next · Esc cancel`
+          : `↑↓ or 1–${count} · Enter select · Esc cancel`;
+        addWrappedWithPrefix(' ', theme.fg('dim', help));
+      }
+      lines.push(theme.fg('accent', '─'.repeat(renderWidth)));
+
+      cachedLines = lines;
+      return lines;
+    }
+
+    return {
+      render,
+      invalidate: () => {
+        cachedLines = undefined;
+      },
+      handleInput,
+    };
+  });
+}
+
+function optionIndexFromDigit(
+  data: string,
+  optionCount: number,
+): number | undefined {
+  if (data.length !== 1) {
+    return undefined;
+  }
+  const code = data.charCodeAt(0);
+  if (code < 49 || code > 57) {
+    return undefined;
+  }
+  const index = code - 49;
+  if (index >= optionCount) {
+    return undefined;
+  }
+  return index;
+}

package/extensions/modified-files/index.ts

@@ -0,0 +1,45 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from '@earendil-works/pi-coding-agent';
+import { TODO_WIDGET_REFRESH_EVENT } from '../todo/session.ts';
+import {
+  commitModifiedFiles,
+  createModifiedFilesStore,
+  refreshModifiedFiles,
+  registerModifiedFilesEvents,
+} from './session.ts';
+import { createModifiedFilesOverlayController } from './ui.ts';
+
+const SHORTCUT = 'f8';
+
+// Pi loads extensions/*/index.ts through export default.
+export default function registerModifiedFiles(pi: ExtensionAPI): void {
+  const store = createModifiedFilesStore();
+  const overlay = createModifiedFilesOverlayController(
+    () => store.files,
+    (ctx) => commitModifiedFiles(store, pi, ctx, []),
+  );
+
+  registerModifiedFilesEvents(pi, store);
+  pi.events.on(TODO_WIDGET_REFRESH_EVENT, (value) => {
+    if (isWidgetContext(value)) {
+      refreshModifiedFiles(store, value);
+    }
+  });
+  pi.registerShortcut(SHORTCUT, {
+    description: 'Toggle edited files',
+    handler: (ctx) => overlay.toggle(ctx),
+  });
+}
+
+function isWidgetContext(
+  value: unknown,
+): value is Pick<ExtensionContext, 'ui' | 'cwd'> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'ui' in value &&
+    'cwd' in value
+  );
+}

package/extensions/modified-files/model.ts

@@ -0,0 +1,74 @@
+import { relative, resolve } from 'node:path';
+
+export const MAX_TRACKED_FILES = 100;
+export const MODIFIED_FILES_SNAPSHOT_TYPE = 'sideroom-modified-files';
+export const MODIFIED_FILES_WIDGET_KEY = 'sideroom-modified-files';
+
+export const FILE_TOOL_NAME = {
+  edit: 'edit',
+  write: 'write',
+} as const;
+
+export type FileToolName = (typeof FILE_TOOL_NAME)[keyof typeof FILE_TOOL_NAME];
+
+export interface ModifiedFile {
+  readonly path: string;
+  readonly toolName: FileToolName;
+}
+
+export function recordModifiedFile(
+  files: readonly ModifiedFile[],
+  path: string,
+  toolName: FileToolName,
+): readonly ModifiedFile[] {
+  return [
+    { path, toolName },
+    ...files.filter((file) => file.path !== path),
+  ].slice(0, MAX_TRACKED_FILES);
+}
+
+export function resolveModifiedPath(
+  cwd: string,
+  path: string,
+): string | undefined {
+  const normalized = path.trim().replace(/^@/, '');
+  if (normalized.length === 0) {
+    return undefined;
+  }
+  return resolve(cwd, normalized);
+}
+
+export function displayModifiedPath(cwd: string, path: string): string {
+  const displayPath = relative(cwd, path);
+  if (displayPath === '' || displayPath.startsWith('..')) {
+    return `external: ${path}`;
+  }
+  return displayPath;
+}
+
+export function readModifiedFilesSnapshot(
+  value: unknown,
+): readonly ModifiedFile[] | undefined {
+  if (!isRecord(value) || !Array.isArray(value.files)) {
+    return undefined;
+  }
+
+  const files: ModifiedFile[] = [];
+  for (const file of value.files) {
+    if (!isRecord(file) || typeof file.path !== 'string') {
+      return undefined;
+    }
+    if (
+      file.toolName !== FILE_TOOL_NAME.edit &&
+      file.toolName !== FILE_TOOL_NAME.write
+    ) {
+      return undefined;
+    }
+    files.push({ path: file.path, toolName: file.toolName });
+  }
+  return files;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}