ethagent 0.2.0 → 1.0.0

package/src/chat/PermissionPrompt.tsx

@@ -0,0 +1,153 @@
+import React, { useMemo } from 'react'
+import { Box, Text } from 'ink'
+import { Surface } from '../ui/Surface.js'
+import { Select } from '../ui/Select.js'
+import { theme } from '../ui/theme.js'
+import type { PermissionDecision, PermissionRequest } from '../tools/contracts.js'
+
+type PermissionPromptProps = {
+  request: PermissionRequest
+  onDecision: (decision: PermissionDecision) => void
+  onCancel: () => void
+}
+
+export const PermissionPrompt: React.FC<PermissionPromptProps> = ({ request, onDecision, onCancel }) => {
+  const options = useMemo(() => permissionOptionsForRequest(request), [request])
+
+  return (
+    <Surface
+      title={request.title}
+      subtitle={request.subtitle}
+      tone={request.kind === 'bash' && request.warning ? 'error' : 'primary'}
+      footer="enter confirms · esc denies"
+    >
+      {request.kind === 'private-continuity-edit' ? (
+        <Box flexDirection="column" marginBottom={1}>
+          <Text color={theme.accentPeach}>{request.changeSummary}</Text>
+          <Text color={theme.textSubtle}>
+            Not reversible by /rewind. A private identity-history snapshot is saved before the edit is applied.
+          </Text>
+          <Box marginTop={1}>
+            <Text color={theme.textSubtle}>target</Text>
+          </Box>
+          <Text color={theme.text}>{request.file}</Text>
+          <Box marginTop={1}>
+            <Text color={theme.accentPrimary}>diff</Text>
+          </Box>
+          <Text color={theme.text}>{request.diff}</Text>
+        </Box>
+      ) : null}
+      {request.kind === 'private-continuity-read' ? (
+        <Box flexDirection="column" marginBottom={1}>
+          <Text color={theme.accentPeach}>read private {request.file}</Text>
+          <Text color={theme.textSubtle}>This reveals private identity continuity to the model for this turn.</Text>
+          <Box marginTop={1}>
+            <Text color={theme.textSubtle}>range</Text>
+          </Box>
+          <Text color={theme.text}>{request.range}</Text>
+        </Box>
+      ) : null}
+      {request.kind === 'edit' || request.kind === 'write' || request.kind === 'delete' ? (
+        <Box flexDirection="column" marginBottom={1}>
+          <Text color={theme.accentPeach}>{request.changeSummary}</Text>
+          <Box marginTop={1}>
+            <Text color={theme.textSubtle}>before</Text>
+          </Box>
+          <Text color={theme.textSubtle}>{request.before || '(empty)'}</Text>
+          <Box marginTop={1}>
+            <Text color={theme.accentPrimary}>after</Text>
+          </Box>
+          <Text color={theme.text}>{request.after || '(empty)'}</Text>
+        </Box>
+      ) : null}
+      {request.kind === 'bash' && request.warning ? (
+        <Box marginBottom={1}>
+          <Text color="#e87070">{request.warning}</Text>
+        </Box>
+      ) : null}
+      <Select options={options} onSubmit={onDecision} onCancel={onCancel} />
+    </Surface>
+  )
+}
+
+export function permissionOptionsForRequest(request: PermissionRequest): Array<{ value: PermissionDecision; label: string; hint?: string; disabled?: boolean }> {
+  if (request.kind === 'bash') {
+    return [
+      { value: 'allow-once', label: 'allow once', hint: 'approve only this command execution' },
+      {
+        value: 'allow-command-project',
+        label: 'always allow this exact command',
+        hint: 'remember this command text for this project',
+        disabled: !request.canPersistExact,
+      },
+      {
+        value: 'allow-command-prefix-project',
+        label: request.commandPrefix ? `always allow ${request.commandPrefix} commands` : 'allow command prefix',
+        hint: 'remember this base command in this working directory for this project',
+        disabled: !request.canPersistPrefix,
+      },
+      { value: 'deny', label: 'deny', hint: 'return a denial back to the model' },
+    ]
+  }
+
+  if (request.kind === 'mcp') {
+    const risk = request.destructive
+      ? 'server marks this tool as destructive'
+      : request.openWorld
+        ? 'server marks this tool as open-world'
+        : request.readOnly
+          ? 'server marks this tool as read-only'
+          : 'server did not mark this tool read-only'
+    return [
+      { value: 'allow-once', label: 'allow once', hint: risk },
+      { value: 'allow-mcp-tool-project', label: 'always allow this MCP tool', hint: request.toolKey },
+      {
+        value: 'allow-mcp-server-project',
+        label: `always allow ${request.serverName}`,
+        hint: 'remember all tools from this MCP server for this project',
+        disabled: !request.canPersistServer,
+      },
+      { value: 'deny', label: 'deny', hint: 'return a denial back to the model' },
+    ]
+  }
+
+  if (request.kind === 'delete') {
+    return [
+      { value: 'allow-once', label: 'delete this file', hint: 'approve this deletion only' },
+      { value: 'deny', label: 'deny', hint: 'keep the file unchanged' },
+    ]
+  }
+
+  if (request.kind === 'private-continuity-read') {
+    return [
+      { value: 'allow-once', label: 'allow once', hint: `read ${request.file}` },
+      { value: 'deny', label: 'deny', hint: 'keep private continuity hidden' },
+    ]
+  }
+
+  if (request.kind === 'private-continuity-edit') {
+    return [
+      { value: 'allow-once', label: 'approve once', hint: `apply this edit to ${request.file}` },
+      { value: 'deny', label: 'deny', hint: 'keep private continuity unchanged' },
+    ]
+  }
+
+  return [
+    { value: 'allow-once', label: 'allow once', hint: 'approve only this action' },
+    { value: 'allow-path-project', label: 'always allow this file', hint: request.relativePath },
+    { value: 'allow-directory-project', label: 'always allow this folder', hint: request.directoryPath },
+    {
+      value: 'allow-kind-project',
+      label:
+        request.kind === 'edit'
+          ? 'always allow edits'
+          : request.kind === 'write'
+            ? 'always allow writes'
+          : request.kind === 'cd'
+            ? 'always allow directory changes'
+            : 'always allow reads',
+      hint: 'remember this tool kind for this project',
+    },
+    { value: 'deny', label: 'deny', hint: 'return a denial back to the model' },
+  ]
+}

package/src/chat/PermissionsView.tsx

@@ -0,0 +1,159 @@
+import React, { useEffect, useMemo, useState } from 'react'
+import { Box, Text } from 'ink'
+import { clearPermissionRules, deletePermissionRule, loadPermissionRules } from '../storage/permissions.js'
+import type { SessionPermissionRule } from '../tools/contracts.js'
+import { Select, type SelectOption } from '../ui/Select.js'
+import { Spinner } from '../ui/Spinner.js'
+import { Surface } from '../ui/Surface.js'
+import { theme } from '../ui/theme.js'
+
+type PermissionsViewProps = {
+  cwd: string
+  onRulesChanged: (rules: SessionPermissionRule[]) => void
+  onNotice: (message: string, variant?: 'info' | 'error' | 'dim') => void
+  onCancel: () => void
+}
+
+type State =
+  | { kind: 'loading' }
+  | { kind: 'error'; message: string }
+  | { kind: 'ready'; rules: SessionPermissionRule[] }
+
+const CLEAR_ALL_VALUE = '__clear_all__'
+
+export const PermissionsView: React.FC<PermissionsViewProps> = ({
+  cwd,
+  onRulesChanged,
+  onNotice,
+  onCancel,
+}) => {
+  const [state, setState] = useState<State>({ kind: 'loading' })
+
+  useEffect(() => {
+    let cancelled = false
+    void (async () => {
+      try {
+        const rules = await loadPermissionRules(cwd)
+        if (!cancelled) setState({ kind: 'ready', rules })
+      } catch (err: unknown) {
+        if (!cancelled) setState({ kind: 'error', message: (err as Error).message })
+      }
+    })()
+    return () => { cancelled = true }
+  }, [cwd])
+
+  const refreshRules = async () => {
+    const rules = await loadPermissionRules(cwd)
+    setState({ kind: 'ready', rules })
+    onRulesChanged(rules)
+    return rules
+  }
+
+  const options = useMemo(
+    () => state.kind === 'ready' ? buildOptions(state.rules) : [],
+    [state],
+  )
+
+  if (state.kind === 'loading') {
+    return (
+      <Surface title="Permissions" subtitle="Loading saved project rules...">
+        <Spinner label="loading permission rules..." />
+      </Surface>
+    )
+  }
+
+  if (state.kind === 'error') {
+    return (
+      <Surface title="Permissions" tone="muted" footer="esc closes">
+        <Text color={theme.dim}>{state.message}</Text>
+      </Surface>
+    )
+  }
+
+  if (state.rules.length === 0) {
+    return (
+      <Surface title="Permissions" tone="muted" footer="esc closes">
+        <Text color={theme.dim}>No saved permission rules for this project.</Text>
+      </Surface>
+    )
+  }
+
+  return (
+    <Surface
+      title="Permissions"
+      subtitle="Saved rules for this project. Enter removes the selected rule."
+      footer="enter removes · esc closes"
+    >
+      <Select
+        options={options}
+        onSubmit={async value => {
+          try {
+            if (value === CLEAR_ALL_VALUE) {
+              await clearPermissionRules(cwd)
+              onRulesChanged([])
+              onCancel()
+              onNotice('cleared saved permission rules for this project.', 'dim')
+              return
+            }
+
+            await deletePermissionRule(cwd, value)
+            const remaining = await refreshRules()
+            if (remaining.length === 0) {
+              onCancel()
+              onNotice('removed the last saved permission rule for this project.', 'dim')
+              return
+            }
+            onNotice(`removed permission rule: ${describeRule(value)}`, 'dim')
+          } catch (err: unknown) {
+            onNotice(`failed to update permission rules: ${(err as Error).message}`, 'error')
+          }
+        }}
+        onCancel={onCancel}
+      />
+      <Box marginTop={1} flexDirection="column">
+        <Text color={theme.dim}>Rules apply only within the current project root.</Text>
+      </Box>
+    </Surface>
+  )
+}
+
+function buildOptions(rules: SessionPermissionRule[]): Array<SelectOption<SessionPermissionRule | typeof CLEAR_ALL_VALUE>> {
+  return [
+    ...rules.map(rule => ({
+      value: rule,
+      label: describeRule(rule),
+      hint: describeRuleScope(rule),
+    })),
+    {
+      value: CLEAR_ALL_VALUE,
+      label: 'Remove all saved rules',
+      hint: 'Clear all remembered permissions for this project',
+    },
+  ]
+}
+
+function describeRule(rule: SessionPermissionRule): string {
+  if (rule.kind === 'bash') {
+    if (rule.scope === 'command') return `bash exact: ${rule.command}`
+    return `bash prefix: ${rule.commandPrefix}`
+  }
+  if (rule.kind === 'mcp') {
+    if (rule.scope === 'tool') return `mcp tool: ${rule.toolKey}`
+    return `mcp server: ${rule.normalizedServerName}`
+  }
+  if (rule.scope === 'kind') {
+    return rule.kind === 'read'
+      ? 'allow all reads'
+      : rule.kind === 'edit'
+        ? 'allow all edits'
+        : 'allow all directory changes'
+  }
+  if (rule.scope === 'path') return `${rule.kind} file: ${rule.path}`
+  return `${rule.kind} folder: ${rule.path}`
+}
+
+function describeRuleScope(rule: SessionPermissionRule): string {
+  if (rule.kind === 'bash') return `cwd ${rule.cwd}`
+  if (rule.kind === 'mcp') return 'MCP project permission'
+  return rule.scope === 'kind' ? 'whole project' : rule.path
+}

package/src/chat/PlanApprovalView.tsx

@@ -0,0 +1,91 @@
+import React, { useState } from 'react'
+import { Box, Text } from 'ink'
+import { Surface } from '../ui/Surface.js'
+import { theme } from '../ui/theme.js'
+import { useAppInput } from '../app/input/AppInputProvider.js'
+
+export type PlanApprovalAction = 'apply' | 'apply-summary' | 'continue'
+
+type PlanApprovalViewProps = {
+  contextLabel: string
+  onSelect: (action: PlanApprovalAction) => void
+  onCancel: () => void
+}
+
+export const PLAN_APPROVAL_OPTIONS: Array<{
+  value: PlanApprovalAction
+  label: string
+  title: string
+  detail: (contextLabel: string) => string
+}> = [
+    {
+      value: 'apply',
+      label: 'Yes, implement this plan',
+      title: 'Switch to Accept Edits and start coding.',
+      detail: contextLabel => `Same conversation. ${contextLabel}.`,
+    },
+    {
+      value: 'apply-summary',
+      label: 'Yes, start a new conversation',
+      title: 'Summarize context and start coding.',
+      detail: () => 'Keeps this conversation active and carries summary plus plan.',
+    },
+    {
+      value: 'continue',
+      label: 'No, stay in Plan mode',
+      title: 'Continue planning with the model.',
+      detail: () => 'No files will be changed.',
+    },
+  ]
+
+export const PlanApprovalView: React.FC<PlanApprovalViewProps> = ({
+  contextLabel,
+  onSelect,
+  onCancel,
+}) => {
+  const [index, setIndex] = useState(0)
+  const selected = PLAN_APPROVAL_OPTIONS[index] ?? PLAN_APPROVAL_OPTIONS[0]!
+
+  useAppInput((input, key) => {
+    if (key.upArrow || input === 'k') {
+      setIndex(current => (current - 1 + PLAN_APPROVAL_OPTIONS.length) % PLAN_APPROVAL_OPTIONS.length)
+    } else if (key.downArrow || input === 'j') {
+      setIndex(current => (current + 1) % PLAN_APPROVAL_OPTIONS.length)
+    } else if (key.return) {
+      onSelect(selected.value)
+    } else if (key.escape) {
+      onCancel()
+    }
+  })
+
+  return (
+    <Surface
+      title="Implement this plan?"
+      tone="muted"
+      footer="Press enter to confirm or esc to go back"
+    >
+      <Box flexDirection="row">
+        <Box flexDirection="column" minWidth={36}>
+          {PLAN_APPROVAL_OPTIONS.map((option, optionIndex) => {
+            const active = optionIndex === index
+            return (
+              <Box key={option.value} flexDirection="row">
+                <Text color={active ? theme.accentMint : theme.dim}>
+                  {active ? '> ' : '  '}
+                  {optionIndex + 1}.{' '}
+                </Text>
+                <Text color={active ? theme.accentMint : theme.text} bold={active}>
+                  {option.label}
+                </Text>
+              </Box>
+            )
+          })}
+        </Box>
+        <Box flexDirection="column" marginLeft={4} flexShrink={1}>
+          <Text color={theme.accentMint} bold>{selected.title}</Text>
+          <Text color={theme.dim}>{selected.detail(contextLabel)}</Text>
+        </Box>
+      </Box>
+    </Surface>
+  )
+}

package/src/chat/ResumeView.tsx

@@ -0,0 +1,267 @@
+import React, { useEffect, useState } from 'react'
+import { Box, Text } from 'ink'
+import { theme } from '../ui/theme.js'
+import { Select, type SelectOption } from '../ui/Select.js'
+import { Spinner } from '../ui/Spinner.js'
+import { Surface } from '../ui/Surface.js'
+import { listSessions, type SessionSummary } from '../storage/sessions.js'
+import { useAppInput } from '../app/input/AppInputProvider.js'
+
+type ResumeViewProps = {
+  currentSessionId: string
+  onResume: (sessionId: string) => void
+  onClearAll: () => void | Promise<void>
+  onCancel: () => void
+}
+
+type State =
+  | { kind: 'loading' }
+  | { kind: 'error'; message: string }
+  | { kind: 'ready'; sessions: SessionSummary[] }
+  | { kind: 'confirmClear'; sessions: SessionSummary[]; error?: string }
+  | { kind: 'clearing'; sessions: SessionSummary[] }
+
+export const CLEAR_ALL_SESSIONS_VALUE = '__clear_all_sessions__'
+
+export const ResumeView: React.FC<ResumeViewProps> = ({ currentSessionId, onResume, onClearAll, onCancel }) => {
+  const [state, setState] = useState<State>({ kind: 'loading' })
+
+  // Allow ESC to close the view during loading / error states
+  // (Select handles ESC only when it's rendered in the 'ready' state)
+  const escActive = state.kind === 'loading' || state.kind === 'error' || (state.kind === 'ready' && state.sessions.length === 0)
+  useAppInput((_input, key) => {
+    if (key.escape) onCancel()
+  }, { isActive: escActive })
+
+  useEffect(() => {
+    let cancelled = false
+    void (async () => {
+      try {
+        const all = await listSessions(50)
+        if (cancelled) return
+        setState({ kind: 'ready', sessions: all })
+      } catch (err: unknown) {
+        if (cancelled) return
+        setState({ kind: 'error', message: (err as Error).message })
+      }
+    })()
+    return () => { cancelled = true }
+  }, [currentSessionId])
+
+  if (state.kind === 'loading') {
+    return (
+      <Surface title="Resume Session" subtitle="Loading projects and directories...">
+        <Spinner label="loading sessions..." />
+      </Surface>
+    )
+  }
+
+  if (state.kind === 'error') {
+    return (
+      <Surface title="Resume Session" tone="muted" footer="esc closes">
+        <Text color={theme.dim}>{state.message}</Text>
+      </Surface>
+    )
+  }
+
+  if (state.kind === 'confirmClear') {
+    return (
+      <Surface
+        title="Clear All Chat Logs?"
+        subtitle={`${state.sessions.length} saved session${state.sessions.length === 1 ? '' : 's'} will be removed.`}
+        tone="error"
+        footer="enter selects · esc returns to resume"
+      >
+        <Box flexDirection="column" marginBottom={1}>
+          <Text color={theme.dim}>Removes saved chats and resume context from this machine.</Text>
+          <Text color={theme.dim}>Config, identities, keys, and local models stay.</Text>
+          {state.error ? <Text color="#e87070">{state.error}</Text> : null}
+        </Box>
+        <Select<'back' | 'clear'>
+          options={[
+            { value: 'back', label: 'back to sessions' },
+            { value: 'clear', label: 'clear all chat logs', hint: 'cannot be undone' },
+          ]}
+          onSubmit={choice => {
+            if (choice === 'back') {
+              setState({ kind: 'ready', sessions: state.sessions })
+              return
+            }
+            void clearAll(state.sessions, onClearAll, setState)
+          }}
+          onCancel={() => setState({ kind: 'ready', sessions: state.sessions })}
+        />
+      </Surface>
+    )
+  }
+
+  if (state.kind === 'clearing') {
+    return (
+      <Surface title="Clearing Chat Logs" subtitle="Removing saved chats and resume context.">
+        <Spinner label="clearing sessions..." />
+      </Surface>
+    )
+  }
+
+  if (state.sessions.length === 0) {
+    return (
+      <Surface title="Resume Session" tone="muted" footer="esc closes">
+        <Text color={theme.dim}>No prior sessions to resume.</Text>
+      </Surface>
+    )
+  }
+
+  const options = buildResumeOptions(state.sessions, currentSessionId)
+
+  return (
+    <Surface
+      title="Resume Session"
+      subtitle="Grouped by project, then working directory."
+      footer="enter resumes · esc closes"
+    >
+      <Box flexDirection="column" marginBottom={1}>
+        <Text color={theme.dim}>Recent projects</Text>
+      </Box>
+      <Select
+        options={options}
+        initialIndex={findInitialIndex(options, currentSessionId)}
+        maxVisible={14}
+        onSubmit={value => {
+          if (value === CLEAR_ALL_SESSIONS_VALUE) {
+            setState({ kind: 'confirmClear', sessions: state.sessions })
+            return
+          }
+          onResume(value)
+        }}
+        onCancel={onCancel}
+      />
+    </Surface>
+  )
+}
+
+export function buildResumeOptions(
+  sessions: SessionSummary[],
+  currentSessionId: string,
+): Array<SelectOption<string>> {
+  const groups = new Map<string, SessionSummary[]>()
+  for (const session of sessions) {
+    const key = session.projectRoot
+    const existing = groups.get(key) ?? []
+    existing.push(session)
+    groups.set(key, existing)
+  }
+
+  const options: Array<SelectOption<string>> = []
+  const manageSpacer: SelectOption<string> = {
+    value: 'separator:spacer',
+    label: '',
+    disabled: true,
+  }
+
+  const clearOption: SelectOption<string> = {
+    value: CLEAR_ALL_SESSIONS_VALUE,
+    label: 'clear all chat logs',
+    hint: 'removes saved chats and resume context',
+    role: 'utility',
+  }
+
+  const orderedGroups = [...groups.values()].sort((left, right) => right[0]!.mtimeMs - left[0]!.mtimeMs)
+
+  for (const group of orderedGroups) {
+    const head = group[0]!
+    options.push({
+      value: `header:${head.projectRoot}`,
+      label: head.projectLabel,
+      hint: compressProjectPath(head.projectRoot),
+      disabled: true,
+    })
+
+    const byDirectory = [...group].sort((left, right) => right.mtimeMs - left.mtimeMs)
+    let lastDirectoryLabel: string | null = null
+
+    for (const session of byDirectory) {
+      if (session.directoryLabel !== lastDirectoryLabel) {
+        lastDirectoryLabel = session.directoryLabel
+        options.push({
+          value: `directory:${head.projectRoot}:${session.directoryLabel}`,
+          label: `in ${formatDirectoryDisplay(session.directoryLabel)}`,
+          hint: undefined,
+          disabled: true,
+        })
+      }
+
+      const baseLabel = formatFirstLine(session.firstUserMessage) || '(empty session)'
+      const markers = [
+        session.id === currentSessionId ? 'current' : '',
+      ].filter(Boolean)
+      const label = markers.length > 0 ? `${baseLabel}  (${markers.join(', ')})` : baseLabel
+      const summaryHint = session.compactedFromSessionId
+        ? `summary from ${session.compactedFromSessionId.slice(0, 8)}`
+        : null
+      const hintParts = [
+        `${session.turnCount} turn${session.turnCount === 1 ? '' : 's'}`,
+        formatRelative(session.mtimeMs),
+        session.id.slice(0, 8),
+        summaryHint,
+      ].filter(Boolean)
+      options.push({
+        value: session.id,
+        label,
+        hint: hintParts.join(' · '),
+      })
+    }
+  }
+
+  // Utility section sits below all session groups with a visual gap
+  options.push(manageSpacer)
+  options.push(clearOption)
+
+  return options
+}
+
+function findInitialIndex(options: Array<SelectOption<string>>, currentSessionId: string): number {
+  const currentIndex = options.findIndex(option => option.value === currentSessionId)
+  if (currentIndex >= 0) return currentIndex
+  return Math.max(0, options.findIndex(option => !option.disabled && option.value !== CLEAR_ALL_SESSIONS_VALUE))
+}
+
+async function clearAll(
+  sessions: SessionSummary[],
+  onClearAll: () => void | Promise<void>,
+  setState: (state: State) => void,
+): Promise<void> {
+  setState({ kind: 'clearing', sessions })
+  try {
+    await onClearAll()
+  } catch (err: unknown) {
+    setState({ kind: 'confirmClear', sessions, error: (err as Error).message })
+  }
+}
+
+function compressProjectPath(input: string): string {
+  const home = process.env.USERPROFILE || process.env.HOME || ''
+  return home && input.startsWith(home) ? `~${input.slice(home.length)}` : input
+}
+
+function formatDirectoryDisplay(input: string): string {
+  if (input === '.' || input === '') return './'
+  return input.startsWith('./') ? input : `./${input}`
+}
+
+function formatFirstLine(text: string): string {
+  const firstLine = text.split('\n', 1)[0] ?? ''
+  if (firstLine.length <= 56) return firstLine
+  return `${firstLine.slice(0, 53)}...`
+}
+
+function formatRelative(ms: number): string {
+  const diffMs = Date.now() - ms
+  const minutes = Math.floor(diffMs / 60_000)
+  if (minutes < 1) return 'just now'
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours}h ago`
+  const days = Math.floor(hours / 24)
+  if (days < 7) return `${days}d ago`
+  return new Date(ms).toISOString().slice(0, 10)
+}