miii-cli 0.1.0

package/src/parser/stream-parser.ts

@@ -0,0 +1,54 @@
+export interface ParsedText { type: 'text'; content: string }
+export interface ParsedTool { type: 'tool_call'; content: string; toolName: string; toolArgs: Record<string, unknown> }
+export type ParsedItem = ParsedText | ParsedTool
+
+const OPEN = '<tool_call>'
+const CLOSE = '</tool_call>'
+
+export class StreamParser {
+  private buf = ''
+  private inTool = false
+
+  feed(token: string): ParsedItem[] {
+    this.buf += token
+    const out: ParsedItem[] = []
+
+    while (true) {
+      if (this.inTool) {
+        const end = this.buf.indexOf(CLOSE)
+        if (end === -1) break
+        const raw = this.buf.slice(0, end).trim()
+        this.buf = this.buf.slice(end + CLOSE.length)
+        this.inTool = false
+        try {
+          const obj = JSON.parse(raw) as { name: string; args?: Record<string, unknown> }
+          out.push({ type: 'tool_call', content: raw, toolName: obj.name, toolArgs: obj.args ?? {} })
+        } catch {
+          out.push({ type: 'text', content: `${OPEN}${raw}${CLOSE}` })
+        }
+      } else {
+        const start = this.buf.indexOf(OPEN)
+        if (start === -1) {
+          const safe = this.buf.length > OPEN.length ? this.buf.slice(0, -OPEN.length) : ''
+          if (safe) { out.push({ type: 'text', content: safe }); this.buf = this.buf.slice(safe.length) }
+          break
+        }
+        if (start > 0) {
+          out.push({ type: 'text', content: this.buf.slice(0, start) })
+          this.buf = this.buf.slice(start)
+        }
+        this.buf = this.buf.slice(OPEN.length)
+        this.inTool = true
+      }
+    }
+    return out
+  }
+
+  flush(): ParsedItem[] {
+    const out: ParsedItem[] = []
+    if (this.buf.trim()) out.push({ type: 'text', content: this.buf })
+    this.buf = ''
+    this.inTool = false
+    return out
+  }
+}

package/src/sessions.ts

@@ -0,0 +1,46 @@
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, existsSync, unlinkSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+import type { ChatMessage } from './types.js'
+
+const SESSIONS_DIR = join(homedir(), '.config', 'miii', 'sessions')
+
+function ensureDir() {
+  mkdirSync(SESSIONS_DIR, { recursive: true })
+}
+
+export function listSessions(): Array<{ name: string; messageCount: number; updatedAt: number }> {
+  ensureDir()
+  return readdirSync(SESSIONS_DIR)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      const name = f.replace('.json', '')
+      const p = join(SESSIONS_DIR, f)
+      let messageCount = 0
+      let updatedAt = 0
+      try {
+        updatedAt = statSync(p).mtimeMs
+        const msgs = JSON.parse(readFileSync(p, 'utf-8'))
+        messageCount = Array.isArray(msgs) ? msgs.length : 0
+      } catch {}
+      return { name, messageCount, updatedAt }
+    })
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+}
+
+export function loadSession(name: string): ChatMessage[] {
+  ensureDir()
+  const p = join(SESSIONS_DIR, `${name}.json`)
+  if (!existsSync(p)) return []
+  try { return JSON.parse(readFileSync(p, 'utf-8')) } catch { return [] }
+}
+
+export function saveSession(name: string, messages: ChatMessage[]) {
+  ensureDir()
+  writeFileSync(join(SESSIONS_DIR, `${name}.json`), JSON.stringify(messages))
+}
+
+export function deleteSession(name: string) {
+  const p = join(SESSIONS_DIR, `${name}.json`)
+  if (existsSync(p)) unlinkSync(p)
+}

package/src/skills/loader.ts

@@ -0,0 +1,109 @@
+import { readFileSync, existsSync, readdirSync } from 'fs'
+import { join, basename } from 'path'
+import { homedir } from 'os'
+
+export interface SkillContext {
+  messages: Array<{ role: string; content: string }>
+  appendMessage: (role: string, content: string) => void
+  setSystemPrompt: (p: string) => void
+  getSystemPrompt: () => string
+}
+
+export interface Skill {
+  name: string
+  ns: string
+  description: string
+  prompt?: string
+  execute?: (args: string, ctx: SkillContext) => string | Promise<string>
+}
+
+const builtin: Skill[] = [
+  {
+    name: 'caveman',
+    ns: 'caveman',
+    description: 'Ultra-compressed terse mode',
+    execute: (_, ctx) => {
+      const cur = ctx.getSystemPrompt()
+      ctx.setSystemPrompt(cur + '\n\nRespond ultra-compressed. Drop articles, filler, pleasantries, hedging. Fragments OK. Technical terms exact.')
+      return 'Caveman mode active.'
+    },
+  },
+  {
+    name: 'normal',
+    ns: 'caveman',
+    description: 'Revert to normal tone',
+    execute: (_, ctx) => {
+      const cur = ctx.getSystemPrompt()
+      ctx.setSystemPrompt(cur.replace(/\n\nRespond ultra-compressed.*$/s, ''))
+      return 'Normal mode.'
+    },
+  },
+  {
+    name: 'review',
+    ns: 'default',
+    description: 'Review codebase for bugs/security/quality',
+    prompt: 'Review the code in this project. Look for bugs, security issues, performance problems, and quality issues. Be specific and actionable. List findings grouped by severity.',
+  },
+  {
+    name: 'help',
+    ns: 'default',
+    description: 'Show available commands',
+    execute: (_, ctx) => {
+      return 'Built-in skills: /caveman:caveman /caveman:normal /review /help\nType /list for all loaded skills.'
+    },
+  },
+  {
+    name: 'list',
+    ns: 'default',
+    description: 'List all skills',
+    execute: () => '',  // handled dynamically in loader.list()
+  },
+  {
+    name: 'models',
+    ns: 'default',
+    description: 'Choose or pull Ollama models',
+    // execute handled specially in App.tsx before skill lookup
+  },
+]
+
+export class SkillLoader {
+  private map = new Map<string, Skill>()
+
+  constructor() {
+    for (const s of builtin) {
+      this.map.set(`${s.ns}:${s.name}`, s)
+      this.map.set(s.name, s)
+    }
+  }
+
+  async loadAll(): Promise<void> {
+    const dirs = [
+      join(homedir(), '.config', 'miii', 'skills'),
+      join(process.cwd(), '.miii', 'skills'),
+    ]
+    for (const dir of dirs) {
+      if (!existsSync(dir)) continue
+      for (const entry of readdirSync(dir)) {
+        if (!entry.endsWith('.md')) continue
+        const name = basename(entry, '.md')
+        const content = readFileSync(join(dir, entry), 'utf-8')
+        const skill: Skill = {
+          name,
+          ns: 'custom',
+          description: content.split('\n')[0].replace(/^#+\s*/, '').trim(),
+          prompt: content,
+        }
+        this.map.set(name, skill)
+        this.map.set(`custom:${name}`, skill)
+      }
+    }
+  }
+
+  get(ref: string): Skill | undefined {
+    return this.map.get(ref)
+  }
+
+  list(): Skill[] {
+    return [...new Set(this.map.values())]
+  }
+}

package/src/tools/index.ts

@@ -0,0 +1,83 @@
+import { readFile, writeFile, deleteFile, listFiles } from '../files/ops.js'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+
+const run = promisify(exec)
+
+export interface Tool {
+  name: string
+  description: string
+  params: string
+  execute: (args: Record<string, unknown>) => Promise<string>
+}
+
+export const tools: Tool[] = [
+  {
+    name: 'read_file',
+    description: 'Read file contents',
+    params: '{"path": "string"}',
+    execute: async ({ path }) => {
+      try { return readFile(path as string) }
+      catch (e) { throw new Error(`read_file: ${e}`) }
+    },
+  },
+  {
+    name: 'list_files',
+    description: 'List directory contents',
+    params: '{"path": "string", "recursive": "boolean (optional)"}',
+    execute: async ({ path, recursive = false }) => {
+      const entries = listFiles(path as string, recursive as boolean)
+      if (!entries.length) return '(empty)'
+      return entries.map(e => `${e.type === 'dir' ? 'd' : 'f'}  ${e.rel}`).join('\n')
+    },
+  },
+  {
+    name: 'edit_file',
+    description: 'Write/overwrite file content',
+    params: '{"path": "string", "content": "string"}',
+    execute: async ({ path, content }) => {
+      writeFile(path as string, content as string)
+      return `written: ${path}`
+    },
+  },
+  {
+    name: 'delete_file',
+    description: 'Delete a file',
+    params: '{"path": "string"}',
+    execute: async ({ path }) => {
+      deleteFile(path as string)
+      return `deleted: ${path}`
+    },
+  },
+  {
+    name: 'run_command',
+    description: 'Run a shell command in cwd',
+    params: '{"command": "string"}',
+    execute: async ({ command }) => {
+      const { stdout, stderr } = await run(command as string, { cwd: process.cwd() })
+      return [stdout, stderr ? `stderr: ${stderr}` : ''].filter(Boolean).join('\n').trim()
+    },
+  },
+]
+
+export function getSystemPrompt(extra = ''): string {
+  const toolDocs = tools.map(t => `- ${t.name}(${t.params}): ${t.description}`).join('\n')
+  return `You are Miii — a fast, local AI coding assistant.
+
+Use tools by emitting:
+<tool_call>
+{"name": "tool_name", "args": {...}}
+</tool_call>
+
+Tools:
+${toolDocs}
+
+Rules:
+- Read existing files before editing them
+- For new files that do not exist yet, call edit_file directly — do not read first
+- read_file returns empty string for missing files, so a blank result means the file is new
+- Show the full content when creating or editing
+- Never delete without confirming
+- Be concise
+- Output plain text only — no markdown, no headers, no bold/italic, no bullet points with *, no fenced code blocks with backticks. Use indentation and plain labels instead. This is a CLI terminal, not a chat UI${extra}`
+}

package/src/tui/App.tsx

@@ -0,0 +1,308 @@
+import React, { useState, useCallback, useRef, useEffect } from 'react'
+import { Box, useStdout, useInput } from 'ink'
+import { StatusBar, Divider } from './components/StatusBar.js'
+import { MessageList } from './components/MessageList.js'
+import { InputArea } from './components/InputArea.js'
+import { ModelPicker } from './components/ModelPicker.js'
+import { stream } from '../llm/stream.js'
+import { listModels, pullModel } from '../llm/ollama.js'
+import type { OllamaModel } from '../llm/ollama.js'
+import { StreamParser } from '../parser/stream-parser.js'
+import { tools, getSystemPrompt } from '../tools/index.js'
+import { readFile } from '../files/ops.js'
+import type { SkillLoader } from '../skills/loader.js'
+import type { Message, Status, ChatMessage, Config } from '../types.js'
+import { generateId } from '../types.js'
+
+interface Props {
+  config: Config
+  skills: SkillLoader
+  cwd: string
+}
+
+const MAX_TOOL_DEPTH = 6
+const RENDER_THROTTLE_MS = 40
+
+function expandAtRefs(text: string): { displayText: string; contextPrefix: string } {
+  const refs = [...text.matchAll(/@([\w./\-]+)/g)]
+  if (!refs.length) return { displayText: text, contextPrefix: '' }
+  const parts: string[] = []
+  for (const m of refs) {
+    try {
+      const content = readFile(m[1])
+      parts.push(`<file path="${m[1]}">\n${content}\n</file>`)
+    } catch {}
+  }
+  return { displayText: text, contextPrefix: parts.length ? parts.join('\n\n') + '\n\n' : '' }
+}
+
+export function App({ config, skills, cwd }: Props) {
+  const { stdout } = useStdout()
+
+  const [messages, setMessages] = useState<Message[]>([{
+    id: 'welcome',
+    role: 'system',
+    content: `local AI coding assistant  ·  ${config.provider}/${config.model}  ·  cwd: ${cwd}`,
+    timestamp: Date.now(),
+  }])
+  const [status, setStatus] = useState<Status>('idle')
+  const [tick, setTick] = useState(0)
+  const [currentModel, setCurrentModel] = useState(config.model)
+  const [scrollOffset, setScrollOffset] = useState(0)
+
+  // model picker
+  const [pickerOpen, setPickerOpen] = useState(false)
+  const [pickerModels, setPickerModels] = useState<OllamaModel[]>([])
+  const [pickerLoading, setPickerLoading] = useState(false)
+  const [pickerError, setPickerError] = useState<string | undefined>()
+  const [pullState, setPullState] = useState<{ name: string; status: string; pct: number | undefined } | undefined>()
+
+  const [systemPrompt, setSystemPrompt] = useState(() => getSystemPrompt(`\n- CWD: ${cwd}`))
+  const systemPromptRef = useRef(systemPrompt)
+  const currentModelRef = useRef(currentModel)
+  const abortRef = useRef<AbortController | null>(null)
+  const pullAbortRef = useRef<AbortController | null>(null)
+  const tokenBufRef = useRef('')
+  const lastRenderRef = useRef(0)
+  const messagesRef = useRef(messages)
+
+  useEffect(() => { systemPromptRef.current = systemPrompt }, [systemPrompt])
+  useEffect(() => { currentModelRef.current = currentModel }, [currentModel])
+  useEffect(() => { messagesRef.current = messages }, [messages])
+
+  useEffect(() => {
+    if (status === 'idle') return
+    const t = setInterval(() => setTick(n => n + 1), 80)
+    return () => clearInterval(t)
+  }, [status])
+
+  // Scroll keybindings — PageUp/PageDn scroll message history
+  const SCROLL_STEP = 5
+  useInput((_input, key) => {
+    if (pickerOpen) return
+    if (key.pageUp) {
+      setScrollOffset(n => Math.min(n + SCROLL_STEP, Math.max(0, messages.length - 1)))
+    }
+    if (key.pageDown) {
+      setScrollOffset(n => Math.max(0, n - SCROLL_STEP))
+    }
+  })
+
+  const cols = stdout.columns ?? 80
+  const rows = stdout.rows ?? 24
+
+  function addMsg(role: Message['role'], content: string, id?: string): string {
+    const mid = id ?? generateId()
+    setMessages(prev => [...prev, { id: mid, role, content, timestamp: Date.now() }])
+    return mid
+  }
+
+  function buildContext(extra?: ChatMessage): ChatMessage[] {
+    const ctx: ChatMessage[] = [{ role: 'system', content: systemPromptRef.current }]
+    for (const m of messagesRef.current) {
+      if (m.role === 'tool') ctx.push({ role: 'user', content: `[tool result]\n${m.content}` })
+      else if (m.role === 'user' || m.role === 'assistant') ctx.push({ role: m.role, content: m.content })
+    }
+    if (extra) ctx.push(extra)
+    return ctx
+  }
+
+  const runLoop = useCallback(async (contextMsgs: ChatMessage[], depth = 0) => {
+    if (depth >= MAX_TOOL_DEPTH) { setStatus('idle'); return }
+    setStatus('streaming')
+
+    const assistantId = generateId()
+    setMessages(prev => [...prev, { id: assistantId, role: 'assistant', content: '', timestamp: Date.now() }])
+
+    const parser = new StreamParser()
+    const pendingTools: Array<{ name: string; args: Record<string, unknown> }> = []
+    let fullText = ''
+
+    abortRef.current = new AbortController()
+
+    await stream({
+      provider: config.provider,
+      model: currentModelRef.current,
+      baseUrl: config.baseUrl,
+      messages: contextMsgs,
+      signal: abortRef.current.signal,
+
+      onToken(token) {
+        fullText += token
+        tokenBufRef.current += token
+        const now = Date.now()
+        if (now - lastRenderRef.current >= RENDER_THROTTLE_MS) {
+          const flush = tokenBufRef.current
+          tokenBufRef.current = ''
+          lastRenderRef.current = now
+          setMessages(prev => prev.map(m => m.id === assistantId ? { ...m, content: m.content + flush } : m))
+        }
+        for (const item of parser.feed(token)) {
+          if (item.type === 'tool_call') pendingTools.push({ name: item.toolName, args: item.toolArgs })
+        }
+      },
+
+      async onDone() {
+        if (tokenBufRef.current) {
+          const flush = tokenBufRef.current
+          tokenBufRef.current = ''
+          setMessages(prev => prev.map(m => m.id === assistantId ? { ...m, content: m.content + flush } : m))
+        }
+        for (const item of parser.flush()) {
+          if (item.type === 'tool_call') pendingTools.push({ name: item.toolName, args: item.toolArgs })
+        }
+
+        if (!pendingTools.length) { setStatus('idle'); return }
+
+        setStatus('tool')
+        const next: ChatMessage[] = [...contextMsgs, { role: 'assistant', content: fullText }]
+
+        for (const tc of pendingTools) {
+          const tool = tools.find(t => t.name === tc.name)
+          const toolId = generateId()
+          if (tool) {
+            try {
+              const result = await tool.execute(tc.args)
+              setMessages(prev => [...prev, { id: toolId, role: 'tool', content: `[${tc.name}]\n${result}`, timestamp: Date.now() }])
+              next.push({ role: 'user', content: `Tool ${tc.name} result:\n${result}` })
+            } catch (e) {
+              const err = `Tool ${tc.name} error: ${e}`
+              setMessages(prev => [...prev, { id: toolId, role: 'tool', content: err, timestamp: Date.now() }])
+              next.push({ role: 'user', content: err })
+            }
+          } else {
+            const unk = `Unknown tool: ${tc.name}`
+            setMessages(prev => [...prev, { id: toolId, role: 'tool', content: unk, timestamp: Date.now() }])
+            next.push({ role: 'user', content: unk })
+          }
+        }
+
+        await runLoop(next, depth + 1)
+      },
+
+      onError(err) {
+        addMsg('system', `error: ${err.message}`)
+        setStatus('idle')
+      },
+    })
+  }, [config])
+
+  // Model picker
+  const openPicker = useCallback(async () => {
+    setPickerOpen(true)
+    setPickerLoading(true)
+    setPickerError(undefined)
+    try {
+      setPickerModels(await listModels(config.baseUrl))
+    } catch (e) {
+      setPickerError(String(e))
+    } finally {
+      setPickerLoading(false)
+    }
+  }, [config.baseUrl])
+
+  const handleModelSelect = useCallback((name: string) => {
+    setCurrentModel(name)
+    setPickerOpen(false)
+    addMsg('system', `model → ${name}`)
+  }, [])
+
+  const handleModelPull = useCallback(async (name: string) => {
+    setPullState({ name, status: 'starting...', pct: undefined })
+    pullAbortRef.current = new AbortController()
+    try {
+      await pullModel(config.baseUrl, name, (s, p) => setPullState({ name, status: s, pct: p }), pullAbortRef.current.signal)
+      setPickerModels(await listModels(config.baseUrl))
+      setPullState(undefined)
+      setCurrentModel(name)
+      setPickerOpen(false)
+      addMsg('system', `pulled ${name} → active`)
+    } catch (e) {
+      setPullState(undefined)
+      setPickerError(`pull failed: ${e}`)
+    }
+  }, [config.baseUrl])
+
+  const handleSubmit = useCallback(async (text: string) => {
+    setScrollOffset(0) // snap to bottom on new message
+    if (text.trim() === '/models') { await openPicker(); return }
+
+    if (text.startsWith('/')) {
+      const [cmd, ...rest] = text.slice(1).split(' ')
+      const skill = skills.get(cmd)
+      if (skill) {
+        if (skill.name === 'list') {
+          addMsg('system', skills.list().map(s => `/${s.ns === 'default' ? '' : s.ns + ':'}${s.name}  — ${s.description}`).join('\n'))
+          return
+        }
+        if (skill.execute) {
+          const ctx = {
+            messages: messagesRef.current.map(m => ({ role: m.role, content: m.content })),
+            appendMessage: (role: string, content: string) => addMsg(role as Message['role'], content),
+            setSystemPrompt: (p: string) => setSystemPrompt(p),
+            getSystemPrompt: () => systemPromptRef.current,
+          }
+          const result = await skill.execute(rest.join(' '), ctx)
+          if (result) addMsg('system', result)
+          return
+        }
+        if (skill.prompt) {
+          addMsg('user', skill.prompt)
+          await runLoop(buildContext({ role: 'user', content: skill.prompt }))
+          return
+        }
+      }
+      addMsg('system', `unknown skill: /${cmd}. Try /list`)
+      return
+    }
+
+    // Expand @file references
+    const { displayText, contextPrefix } = expandAtRefs(text)
+    addMsg('user', displayText)
+    const llmContent = contextPrefix + text
+    await runLoop(buildContext({ role: 'user', content: llmContent }))
+  }, [skills, runLoop, openPicker])
+
+  const handleAbort = useCallback(() => {
+    abortRef.current?.abort()
+    setStatus('idle')
+    tokenBufRef.current = ''
+  }, [])
+
+  const skillList = skills.list()
+
+  return (
+    <Box flexDirection="column" height={rows}>
+      <StatusBar model={currentModel} provider={config.provider} status={status} tick={tick} />
+      <Divider cols={cols} />
+      {pickerOpen ? (
+        <ModelPicker
+          models={pickerModels}
+          current={currentModel}
+          loading={pickerLoading}
+          error={pickerError}
+          pull={pullState}
+          onSelect={handleModelSelect}
+          onPull={handleModelPull}
+          onClose={() => { setPickerOpen(false); setPullState(undefined) }}
+        />
+      ) : (
+        <MessageList
+          messages={messages}
+          rows={rows - 8}
+          cols={cols}
+          scrollOffset={scrollOffset}
+          streaming={status === 'streaming'}
+        />
+      )}
+      <Divider cols={cols} />
+      <InputArea
+        status={status}
+        skills={skillList}
+        cwd={cwd}
+        onSubmit={handleSubmit}
+        onAbort={handleAbort}
+      />
+    </Box>
+  )
+}