@dotdrelle/wiki-manager 0.6.17

package/src/shell/tui.tsx

@@ -0,0 +1,205 @@
+/** @jsxImportSource @opentui/solid */
+import { execFileSync } from 'node:child_process';
+import { render, useKeyboard, useRenderer, useSelectionHandler, useTerminalDimensions } from '@opentui/solid';
+import { createMemo, createSignal, onCleanup } from 'solid-js';
+import { FileEditorDialog } from './FileEditorDialog';
+import { LeftPane } from './LeftPane';
+import { RightPane } from './RightPane';
+import { SlashDialog } from './SlashDialog';
+import { useSession } from './useSession';
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+function copyToClipboard(text: string, renderer: unknown) {
+  try {
+    if ((renderer as any).copyToClipboardOSC52?.(text)) return true;
+  } catch {
+    // Fall through to platform clipboard tools.
+  }
+  try {
+    if (process.platform === 'darwin') {
+      execFileSync('pbcopy', [], { input: text });
+      return true;
+    }
+    if (process.platform === 'win32') {
+      execFileSync('clip', [], { input: text });
+      return true;
+    }
+    try {
+      execFileSync('wl-copy', [], { input: text });
+      return true;
+    } catch {
+      execFileSync('xclip', ['-selection', 'clipboard'], { input: text });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+
+function App(props: { agent: unknown; packageJson: Record<string, unknown> }) {
+  const renderer = useRenderer();
+  const dimensions = useTerminalDimensions();
+  const [spinnerIndex, setSpinnerIndex] = createSignal(0);
+  const [exitHint, setExitHint] = createSignal(false);
+  const [copyHint, setCopyHint] = createSignal<string | null>(null);
+  const [chatInputHeight, setChatInputHeight] = createSignal(3);
+  let ctrlCTimer: ReturnType<typeof setTimeout> | null = null;
+  let copyHintTimer: ReturnType<typeof setTimeout> | null = null;
+  let selectionCopyTimer: ReturnType<typeof setTimeout> | null = null;
+  let lastCopiedSelection = '';
+  const state = useSession(props);
+  const conversationRows = createMemo(() => Math.max(4, dimensions().height - 5 - chatInputHeight()));
+  const rightColumns = createMemo(() => {
+    const width = dimensions().width;
+    return Math.max(26, Math.min(44, Math.floor(width * 0.32)));
+  });
+  const leftColumns = createMemo(() => Math.max(32, dimensions().width - rightColumns() - 1));
+  const conversationColumns = createMemo(() => {
+    return Math.max(24, leftColumns() - 4);
+  });
+  const submit = (value?: string) => {
+    if (state.slash()) {
+      state.completeSelected();
+      return;
+    }
+    void state.submitInput(value).then((result) => {
+      if (result?.exit) renderer.destroy();
+    });
+  };
+
+  const showCopyHint = (message: string) => {
+    setCopyHint(message);
+    if (copyHintTimer) clearTimeout(copyHintTimer);
+    copyHintTimer = setTimeout(() => { setCopyHint(null); copyHintTimer = null; }, 1400);
+  };
+
+  useSelectionHandler((selection: any) => {
+    const text = String(selection?.getSelectedText?.() ?? '').trimEnd();
+    if (!text.trim()) return;
+    if (selectionCopyTimer) clearTimeout(selectionCopyTimer);
+    selectionCopyTimer = setTimeout(() => {
+      selectionCopyTimer = null;
+      if (text === lastCopiedSelection) return;
+      lastCopiedSelection = text;
+      showCopyHint(copyToClipboard(text, renderer) ? 'Selection copied.' : 'Selection ready. Use terminal copy.');
+    }, selection?.isDragging ? 700 : 80);
+  });
+
+  onCleanup(() => {
+    if (copyHintTimer) clearTimeout(copyHintTimer);
+    if (selectionCopyTimer) clearTimeout(selectionCopyTimer);
+  });
+
+  const spinnerTimer = setInterval(() => {
+    if (state.busy()) setSpinnerIndex((value) => (value + 1) % 10);
+  }, 90);
+  onCleanup(() => {
+    clearInterval(spinnerTimer);
+    if (ctrlCTimer) clearTimeout(ctrlCTimer);
+  });
+
+  useKeyboard((key) => {
+    if (state.activeEditor()) {
+      if (key.name === 'escape') state.closeEditor();
+      return;
+    }
+    if (key.ctrl && key.name === 'c') {
+      if (state.busy()) {
+        state.abort();
+        return;
+      }
+      if (exitHint()) {
+        renderer.destroy();
+        return;
+      }
+      setExitHint(true);
+      if (ctrlCTimer) clearTimeout(ctrlCTimer);
+      ctrlCTimer = setTimeout(() => {
+        setExitHint(false);
+        ctrlCTimer = null;
+      }, 1600);
+      return;
+    }
+    if (key.ctrl && key.name === 'q') {
+      state.toggleRightTab();
+      return;
+    }
+    if (state.busy()) return;
+    if (key.name === 'tab') state.completeSelected();
+    if (key.name === 'pageup') state.scrollConversation(conversationRows());
+    else if (key.name === 'pagedown') state.scrollConversation(-conversationRows());
+    if (key.name === 'up' && state.slash()) state.moveCompletion(-1);
+    else if (key.name === 'down' && state.slash()) state.moveCompletion(1);
+    else if (key.name === 'up' && !state.input().includes('\n')) state.historyUp();
+    else if (key.name === 'down' && !state.input().includes('\n')) state.historyDown();
+    else if (key.name === 'escape') {
+      if (state.slash()) state.dismissSlash();
+      else state.setInput('');
+    }
+  });
+
+  const hintLine = () => {
+    if (copyHint()) return copyHint();
+    if (exitHint()) return 'Press Ctrl+C again to exit.';
+    return null;
+  };
+
+  return (
+    <box width="100%" height="100%" flexDirection="row">
+      <LeftPane
+        width={leftColumns()}
+        title={state.title()}
+        statusLine={state.statusLine()}
+        hintLine={hintLine()}
+        showWelcome={state.showWelcome()}
+        messages={state.messages()}
+        prompt={state.prompt()}
+        input={state.input()}
+        busy={state.busy()}
+        chatMode={state.chatMode()}
+        chatFocused={!state.activeEditor()}
+        setInput={state.setInput}
+        submit={submit}
+        conversationRows={conversationRows()}
+        conversationColumns={conversationColumns()}
+        conversationScroll={state.conversationScroll()}
+        scrollConversation={state.scrollConversation}
+        spinnerFrame={SPINNER_FRAMES[spinnerIndex()] ?? SPINNER_FRAMES[0]}
+        onInputHeightChange={setChatInputHeight}
+        onCopy={(content) => showCopyHint(copyToClipboard(content, renderer) ? 'Copied.' : 'Copy failed.')}
+      />
+      <box width={1} height="100%" flexDirection="column">
+        {Array.from({ length: dimensions().height }, () => (
+          <text fg="#4B5563">│</text>
+        ))}
+      </box>
+      <RightPane
+        width={rightColumns()}
+        activities={state.activities()}
+        logs={state.logs()}
+        plan={state.plan()}
+        queueItems={state.queueItems()}
+        queueInfo={state.queueInfo()}
+        activeTab={state.rightTab()}
+        onTabClick={state.selectRightTab}
+      />
+      <SlashDialog context={state.activeEditor() ? null : state.slash()} />
+      <FileEditorDialog
+        editor={state.activeEditor()}
+        width={dimensions().width}
+        height={dimensions().height}
+        onSave={state.saveEditor}
+        onCancel={state.closeEditor}
+      />
+    </box>
+  );
+}
+
+export async function runOpenTuiShell({ agent, packageJson }: { agent: unknown; packageJson: Record<string, unknown> }) {
+  await render(() => <App agent={agent} packageJson={packageJson} />, {
+    exitOnCtrlC: false,
+    useMouse: true,
+    targetFps: 30,
+  });
+}

package/src/shell/useAgent.ts

@@ -0,0 +1,47 @@
+import { createSignal } from 'solid-js';
+import { runLine } from './repl.js';
+
+export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; refresh: () => void; addLog: (line: string) => void }) {
+  const [busy, setBusy] = createSignal(false);
+  const [abortController, setAbortController] = createSignal<AbortController | null>(null);
+
+  async function submit(line: string) {
+    const trimmed = line.trim();
+    if (!trimmed) return { exit: false };
+    if (busy()) return { exit: false, busy: true };
+
+    const controller = new AbortController();
+    setAbortController(controller);
+    props.session._abortSignal = controller.signal;
+    setBusy(true);
+    props.addLog(`input: ${trimmed}`);
+
+    try {
+      const result = await runLine(trimmed, {
+        agent: props.agent,
+        packageJson: props.packageJson,
+        session: props.session,
+        onUpdate: props.refresh,
+        onStep: props.addLog,
+        chatMode: props.chatMode(),
+      });
+      props.refresh();
+      return result;
+    } catch (err: any) {
+      if (err?.name === 'AbortError') return { exit: false, aborted: true };
+      props.addLog(`error: ${err instanceof Error ? err.message : String(err)}`);
+      return { exit: false };
+    } finally {
+      delete props.session._abortSignal;
+      setAbortController(null);
+      setBusy(false);
+    }
+  }
+
+  function abort() {
+    abortController()?.abort();
+    props.addLog('interrupt requested');
+  }
+
+  return { busy, submit, abort };
+}

package/src/shell/useSession.ts

@@ -0,0 +1,370 @@
+import { writeFileSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { createMemo, createSignal, onCleanup } from 'solid-js';
+import { formatMcpToolResult, callMcpTool } from '../core/mcp.js';
+import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
+import { formatPlanStatus, formatCompletedActivities } from '../core/plan.js';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { queueCounts, startNextQueuedJob, syncQueueWithActivity } from '../core/jobQueue.js';
+import type { ActiveFileEditor } from './FileEditorDialog';
+import {
+  completionContext,
+  completionDescription,
+  conversationMessages,
+  createSession,
+} from './repl.js';
+import { useAgent } from './useAgent';
+
+function buildContinuationPrompt(session: any, completed: any[]): string {
+  const originalTask = [...conversationMessages(session)]
+    .reverse()
+    .find((message: any) => message.role === 'user'
+      && !String(message.content ?? '').startsWith('Completed activities:')
+      && !String(message.content ?? '').startsWith('Original task:'))?.content;
+  return [
+    originalTask ? `Original task:\n${originalTask}\n` : null,
+    'Completed activities:',
+    formatCompletedActivities(completed) || '(none)',
+    session.headlessPlan ? `\nPlan status:\n${formatPlanStatus(session.headlessPlan)}` : null,
+    '\nContinue the plan. Start the next pending step only.',
+    'If all steps are complete, provide a final summary.',
+  ].filter(Boolean).join('\n');
+}
+
+export function useSession(props: { agent: unknown; packageJson: Record<string, unknown> }) {
+  const session = createSession();
+  const [version, setVersion] = createSignal(0);
+  const [logs, setLogs] = createSignal<string[]>([]);
+  const [input, setInput] = createSignal('');
+  const [chatMode, setChatMode] = createSignal(false);
+  (session as any).chatMode = false;
+  const [dismissedSlashInput, setDismissedSlashInput] = createSignal<string | null>(null);
+  const [history, setHistory] = createSignal<string[]>([]);
+  const [historyIndex, setHistoryIndex] = createSignal<number | null>(null);
+  const [selectedCompletion, setSelectedCompletion] = createSignal(0);
+  const [conversationScroll, setConversationScroll] = createSignal(0);
+  const [showWelcome, setShowWelcome] = createSignal(true);
+  const [activeEditor, setActiveEditor] = createSignal<ActiveFileEditor | null>(null);
+  const [rightTab, setRightTab] = createSignal<'plan' | 'queue'>('plan');
+  const pollBusy = new Set<string>();
+  const matchedActivityKeys = new Set<string>();
+  const lastActivityLines = new Map<string, string>();
+  const lastActivityDetails = new Map<string, string>();
+
+  const refresh = () => setVersion((value) => value + 1);
+  (session as any)._onPlanUpdate = refresh;
+  (session as any)._onOpenEditor = (editor: ActiveFileEditor) => {
+    setShowWelcome(false);
+    setActiveEditor(editor);
+  };
+  const addLog = (line: string) => {
+    setLogs((items) => [...items, `${new Date().toLocaleTimeString()} ${line}`].slice(-200));
+  };
+  const agent = useAgent({ agent: props.agent, packageJson: props.packageJson, session, chatMode, refresh, addLog });
+
+  const messages = createMemo(() => {
+    version();
+    return [...conversationMessages(session)];
+  });
+  const prompt = createMemo(() => {
+    version();
+    return chatMode() ? '[chat] › ' : '[agent] › ';
+  });
+  const title = createMemo(() => {
+    version();
+    const workspace = session.workspace ?? 'myspace';
+    const profile = session.wikirc?.profile ?? 'donna';
+    return `${workspace} > ${profile}`;
+  });
+  const statusLine = createMemo(() => {
+    version();
+    return [
+      `wiki-manager ${props.packageJson.version ?? ''}`.trim(),
+      session.workspace ? session.workspace : 'no workspace',
+      session.wikirc?.profile ? session.wikirc.profile : 'no wikirc',
+      session.language ? session.language : 'no language',
+      session.llm ? 'llm ready' : 'llm limited',
+    ].join('  ');
+  });
+  const slash = createMemo(() => {
+    if (input() === dismissedSlashInput()) return null;
+    const context = completionContext(input(), session);
+    if (!context) return null;
+    return {
+      ...context,
+      selected: Math.min(selectedCompletion(), Math.max(0, context.matches.length - 1)),
+      items: context.matches.slice(0, 10).map((value: string) => ({
+        value,
+        description: completionDescription(value, context.parts),
+      })),
+    };
+  });
+  const mcpServers = createMemo(() => {
+    version();
+    return Object.entries(session.mcp ?? {}).map(([name, value]: [string, any]) => ({
+      name,
+      status: value?.status ?? 'missing',
+      detail: value?.detail ?? '',
+    }));
+  });
+  let lastVisibleActivities: any[] = [];
+  let lastVisiblePlan: Array<{ step: number; description: string; status: string }> | null = null;
+  const activities = createMemo(() => {
+    version();
+    const current = sessionActivities(session);
+    if (current.length > 0) {
+      lastVisibleActivities = current.map((activity) => ({ ...activity }));
+      return current;
+    }
+    return agent.busy() && lastVisibleActivities.length > 0
+      ? lastVisibleActivities.map((activity) => ({ ...activity }))
+      : current;
+  });
+  const queueItems = createMemo(() => {
+    version();
+    return ((session as any).jobQueue ?? []).map((item: any) => ({ ...item }));
+  });
+  const queueInfo = createMemo(() => {
+    version();
+    return queueCounts(session);
+  });
+  const plan = createMemo(() => {
+    version();
+    const p = (session as any).headlessPlan as Array<{ step: number; description: string; status: string }> | null;
+    const current = p ? p.map((s) => ({ ...s })) : null;
+    if (current && current.length > 0) {
+      lastVisiblePlan = current.map((step) => ({ ...step }));
+      return current;
+    }
+    return agent.busy() && lastVisiblePlan && lastVisiblePlan.length > 0
+      ? lastVisiblePlan.map((step) => ({ ...step }))
+      : current;
+  });
+
+  const activityPollTimer = setInterval(() => {
+    for (const activity of sessionActivities(session)) {
+      if (activity.terminal || !activity.poll) continue;
+      const key = activity.key ?? `${activity.poll.server}:${activity.id ?? activity.label}`;
+      if (pollBusy.has(key)) continue;
+      const endpoint = (session.mcp as any)?.[activity.poll.server];
+      if (!endpoint || endpoint.status !== 'connected') continue;
+      const intervalMs = activity.poll.intervalMs ?? 2500;
+      const lastPolledAt = Date.parse((activity as any).lastPolledAt ?? '0');
+      if (Date.now() - lastPolledAt < intervalMs) continue;
+      pollBusy.add(key);
+      (activity as any).lastPolledAt = new Date().toISOString();
+      void callMcpTool(session.mcp, activity.poll.server, activity.poll.tool, activity.poll.args ?? {})
+        .then((result) => {
+          const payload = parseJsonText(formatMcpToolResult(result));
+          const polledActivity = extractActivity(payload, {
+            server: activity.poll.server,
+            tool: activity.poll.tool,
+          });
+          if (polledActivity) {
+            dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+              origin: 'poll',
+              payload: { activity: polledActivity },
+            }));
+            syncQueueWithActivity(session, polledActivity);
+            refresh();
+            const updated = sessionActivities(session).find((a) => a.key === key);
+            if (updated) {
+              const line = `${updated.label ?? key} -> ${updated.status}${updated.error ? ` (${updated.error})` : ''}`;
+              if (lastActivityLines.get(key) !== line) {
+                lastActivityLines.set(key, line);
+                addLog(`activity: ${line}`);
+              }
+              const detail = (updated as any).progress?.detail ?? null;
+              if (detail && lastActivityDetails.get(key) !== detail) {
+                lastActivityDetails.set(key, detail);
+                const shortLabel = (updated as any).progress?.label ?? updated.label ?? key;
+                addLog(`${shortLabel}: ${detail}`);
+              }
+            }
+            if (updated?.terminal && !matchedActivityKeys.has(key)) {
+              matchedActivityKeys.add(key);
+              void startNextQueuedJob(session, { addLog, refresh });
+              const plan = (session as any).headlessPlan;
+              const stillRunning = sessionActivities(session).filter((a) => !a.terminal && a.poll);
+              const pendingSteps = (plan ?? []).filter((s: any) => s.status === 'pending');
+              if (stillRunning.length === 0 && pendingSteps.length > 0 && !agent.busy()) {
+                const completedAll = sessionActivities(session).filter((a) => a.terminal);
+                const prompt = buildContinuationPrompt(session, completedAll);
+                void agent.submit(prompt);
+              }
+            }
+          }
+        })
+        .catch((err) => {
+          addLog(`activity poll error: ${err instanceof Error ? err.message : String(err)}`);
+        })
+        .finally(() => {
+          pollBusy.delete(key);
+        });
+    }
+  }, 1000);
+  onCleanup(() => clearInterval(activityPollTimer));
+
+  const queueFallbackTimer = setInterval(() => {
+    if ((session as any).jobQueue?.some((item: any) => item.status === 'waiting')) {
+      void startNextQueuedJob(session, { addLog, refresh });
+    }
+  }, 10000);
+  onCleanup(() => clearInterval(queueFallbackTimer));
+
+  async function submitInput(submittedValue?: string) {
+    const line = typeof submittedValue === 'string' && submittedValue.trim() ? submittedValue : input();
+    if (agent.busy()) return { exit: false, busy: true };
+    setInput('');
+    setConversationScroll(0);
+    if (line.trim()) {
+      setShowWelcome(false);
+      setHistory((items) => [...items, line].slice(-100));
+    }
+    setHistoryIndex(null);
+    matchedActivityKeys.clear();
+    lastActivityLines.clear();
+    lastActivityDetails.clear();
+    const result = await agent.submit(line);
+    if ((result as any)?.setMode === 'chat') {
+      setChatMode(true);
+      (session as any).chatMode = true;
+      refresh();
+    } else if ((result as any)?.setMode === 'agent') {
+      setChatMode(false);
+      (session as any).chatMode = false;
+      refresh();
+    }
+    return result;
+  }
+
+  function updateInput(value: string) {
+    setInput(value);
+    if (value !== dismissedSlashInput()) setDismissedSlashInput(null);
+  }
+
+  function dismissSlash() {
+    if (slash()) setDismissedSlashInput(input());
+  }
+
+  function completeSelected() {
+    const context = slash();
+    if (!context || context.items.length === 0) return;
+    const selected = context.items[context.selected]?.value;
+    if (!selected) return;
+    const lastSpace = input().lastIndexOf(' ');
+    const base = input().endsWith(' ') ? input() : input().slice(0, lastSpace + 1);
+    setInput(`${base}${selected} `);
+    setSelectedCompletion(0);
+  }
+
+  function moveCompletion(delta: number) {
+    const count = slash()?.items.length ?? 0;
+    if (!count) return;
+    setSelectedCompletion((value) => (value + delta + count) % count);
+  }
+
+  function historyUp() {
+    const items = history();
+    if (!items.length) return;
+    const next = historyIndex() === null ? items.length - 1 : Math.max(0, historyIndex()! - 1);
+    setHistoryIndex(next);
+    setInput(items[next] ?? '');
+  }
+
+  function historyDown() {
+    const items = history();
+    const current = historyIndex();
+    if (current === null) return;
+    const next = current + 1;
+    if (next >= items.length) {
+      setHistoryIndex(null);
+      setInput('');
+      return;
+    }
+    setHistoryIndex(next);
+    setInput(items[next] ?? '');
+  }
+
+  function scrollConversation(delta: number) {
+    setConversationScroll((value) => Math.max(0, value + delta));
+  }
+
+  function toggleRightTab() {
+    setRightTab((value) => value === 'plan' ? 'queue' : 'plan');
+  }
+
+  function selectRightTab(tab: 'plan' | 'queue') {
+    setRightTab(tab);
+  }
+
+  function closeEditor() {
+    setActiveEditor(null);
+  }
+
+  function saveEditor(content: string) {
+    const editor = activeEditor();
+    if (!editor) return { ok: false as const, error: 'No active editor.' };
+    if (!session.workspacePath) return { ok: false as const, error: 'No workspace loaded.' };
+    const workspaceRoot = resolve(session.workspacePath);
+    const targetPath = resolve(editor.filePath);
+    const rel = relative(workspaceRoot, targetPath);
+    if (rel === '' || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+      return { ok: false as const, error: 'Refusing to save outside the workspace.' };
+    }
+    try {
+      writeFileSync(targetPath, content, 'utf8');
+      conversationMessages(session).push({ role: 'command', content: `Saved file: ${editor.displayPath}` });
+      setActiveEditor(null);
+      refresh();
+      return { ok: true as const };
+    } catch (err) {
+      return { ok: false as const, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  function abort() {
+    agent.abort();
+    dispatchAgentEvent(session, createAgentEvent('plan_set', {
+      origin: 'system',
+      payload: { steps: null },
+    }));
+    matchedActivityKeys.clear();
+    refresh();
+  }
+
+  return {
+    session,
+    messages,
+    logs,
+    input,
+    setInput: updateInput,
+    title,
+    statusLine,
+    chatMode,
+    showWelcome,
+    activeEditor,
+    prompt,
+    slash,
+    mcpServers,
+    activities,
+    queueItems,
+    queueInfo,
+    rightTab,
+    toggleRightTab,
+    selectRightTab,
+    plan,
+    conversationScroll,
+    scrollConversation,
+    busy: agent.busy,
+    abort,
+    submitInput,
+    completeSelected,
+    dismissSlash,
+    moveCompletion,
+    historyUp,
+    historyDown,
+    closeEditor,
+    saveEditor,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+    "allowJs": true,
+    "checkJs": false,
+    "strict": false,
+    "skipLibCheck": true,
+    "lib": ["ES2022"],
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}