miii-cli 0.2.0 → 0.2.2

package/src/parser/stream-parser.ts

@@ -1,196 +0,0 @@
-import { appendFileSync } from 'fs'
-
-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>'
-const CTAG_OPEN = '<content>'
-const CTAG_CLOSE = '</content>'
-const OLD_OPEN = '<old>'
-const OLD_CLOSE = '</old>'
-const NEW_OPEN = '<new>'
-const NEW_CLOSE = '</new>'
-const DEBUG_LOG = '/tmp/miii-debug.log'
-
-function dbg(msg: string) {
-  try { appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${msg}\n`) } catch {}
-}
-
-// Fix literal newlines/tabs inside JSON string values — common LLM output mistake
-function sanitizeJson(s: string): string {
-  let result = ''
-  let inString = false
-  let escaped = false
-  for (const ch of s) {
-    if (escaped) {
-      result += ch
-      escaped = false
-    } else if (ch === '\\' && inString) {
-      result += ch
-      escaped = true
-    } else if (ch === '"') {
-      result += ch
-      inString = !inString
-    } else if (inString && ch === '\n') {
-      result += '\\n'
-    } else if (inString && ch === '\r') {
-      result += '\\r'
-    } else if (inString && ch === '\t') {
-      result += '\\t'
-    } else {
-      result += ch
-    }
-  }
-  return result
-}
-
-function parseToolJson(s: string): { name: string; args?: Record<string, unknown> } {
-  try { return JSON.parse(s) }
-  catch { return JSON.parse(sanitizeJson(s)) }
-}
-
-// Find end of a JSON object starting at `from`, correctly tracking strings
-function findJsonEnd(text: string, from: number): number {
-  let depth = 0, inStr = false, escaped = false
-  for (let i = from; i < text.length; i++) {
-    const ch = text[i]
-    if (escaped) { escaped = false; continue }
-    if (ch === '\\' && inStr) { escaped = true; continue }
-    if (ch === '"') { inStr = !inStr; continue }
-    if (inStr) continue
-    if (ch === '{') depth++
-    else if (ch === '}') { depth--; if (depth === 0) return i }
-  }
-  return -1
-}
-
-// For file-writing tools: content field may have unescaped chars — extract with lastIndexOf heuristic
-function extractFileToolArgs(text: string, toolName: string): Record<string, unknown> | null {
-  if (!text.includes(`"${toolName}"`)) return null
-  const args: Record<string, string> = {}
-
-  const pathM = text.match(/"path"\s*:\s*"([^"]*)"/)
-  if (pathM) args.path = pathM[1]
-
-  // content is always the last string field — find its opening quote, take to last " before final }}
-  const ctIdx = text.indexOf('"content"')
-  if (ctIdx !== -1) {
-    const colon = text.indexOf(':', ctIdx)
-    const openQ = text.indexOf('"', colon + 1)
-    const lastBrace = text.lastIndexOf('}')
-    const closeQ = text.lastIndexOf('"', lastBrace - 1)
-    if (openQ !== -1 && closeQ > openQ) {
-      const raw = text.slice(openQ + 1, closeQ)
-      args.content = raw
-        .replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t')
-        .replace(/\\"/g, '"').replace(/\\\\/g, '\\')
-    }
-  }
-
-  // For patch_file: extract old/new fields
-  const oldM = text.match(/"old"\s*:\s*"([\s\S]*?)"(?:\s*,|\s*\})/)
-  if (oldM) args.old = oldM[1].replace(/\\n/g, '\n').replace(/\\"/g, '"')
-  const newM = text.match(/"new"\s*:\s*"([\s\S]*?)"(?:\s*,|\s*\})/)
-  if (newM) args.new = newM[1].replace(/\\n/g, '\n').replace(/\\"/g, '"')
-
-  return Object.keys(args).length > 0 ? args : null
-}
-
-// Extract a bare tool-call JSON from arbitrary text (LLM skipped <tool_call> wrapper)
-export function extractBareToolCall(text: string): { name: string; args: Record<string, unknown> } | null {
-  // First try standard JSON parsing
-  let pos = 0
-  while (true) {
-    const start = text.indexOf('{"name"', pos)
-    if (start === -1) break
-    const end = findJsonEnd(text, start)
-    if (end === -1) break
-    try {
-      const obj = parseToolJson(text.slice(start, end + 1))
-      if (typeof obj.name === 'string') return { name: obj.name, args: (obj.args ?? {}) as Record<string, unknown> }
-    } catch {}
-    pos = start + 1
-  }
-
-  // Fallback: content-aware extraction for file-writing tools (immune to unescaped chars)
-  for (const name of ['edit_file', 'create_file', 'patch_file']) {
-    const args = extractFileToolArgs(text, name)
-    if (args) return { name, args }
-  }
-
-  return null
-}
-
-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 {
-          dbg(`raw block (${raw.length} chars): ${raw.slice(0, 300)}`)
-          // Extract named content blocks so file content never needs JSON escaping
-          const extraArgs: Record<string, string> = {}
-          let jsonPart = raw
-
-          function extractBlock(open: string, close: string, key: string): void {
-            const s = raw.indexOf(open), e = raw.indexOf(close)
-            if (s === -1 || e === -1 || e <= s) return
-            let val = raw.slice(s + open.length, e)
-            if (val.startsWith('\n')) val = val.slice(1)
-            if (val.endsWith('\n')) val = val.slice(0, -1)
-            extraArgs[key] = val
-            // shrink jsonPart to before the first block
-            const blockStart = raw.indexOf(open)
-            if (blockStart < jsonPart.length) jsonPart = raw.slice(0, blockStart).trim()
-          }
-
-          extractBlock(CTAG_OPEN, CTAG_CLOSE, 'content')
-          extractBlock(OLD_OPEN, OLD_CLOSE, 'old')
-          extractBlock(NEW_OPEN, NEW_CLOSE, 'new')
-
-          const obj = parseToolJson(jsonPart)
-          obj.args = { ...(obj.args ?? {}), ...extraArgs }
-          dbg(`parsed ok: name=${obj.name} args_keys=${Object.keys(obj.args).join(',')}`)
-          out.push({ type: 'tool_call', content: raw, toolName: obj.name, toolArgs: obj.args })
-        } catch (e) {
-          dbg(`parse FAILED: ${e} | raw: ${raw.slice(0, 300)}`)
-          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

@@ -1,54 +0,0 @@
-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 })
-}
-
-function sanitizeName(name: string): string {
-  if (!/^[\w-]+$/.test(name)) throw new Error(`invalid session name: ${name}`)
-  return name
-}
-
-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, `${sanitizeName(name)}.json`)
-  if (!existsSync(p)) return []
-  try {
-    const parsed = JSON.parse(readFileSync(p, 'utf-8'))
-    return Array.isArray(parsed) ? parsed : []
-  } catch { return [] }
-}
-
-export function saveSession(name: string, messages: ChatMessage[]) {
-  ensureDir()
-  writeFileSync(join(SESSIONS_DIR, `${sanitizeName(name)}.json`), JSON.stringify(messages))
-}
-
-export function deleteSession(name: string) {
-  const p = join(SESSIONS_DIR, `${sanitizeName(name)}.json`)
-  if (existsSync(p)) unlinkSync(p)
-}

package/src/skills/loader.ts

@@ -1,144 +0,0 @@
-import { readFileSync, existsSync, readdirSync } from 'fs'
-import { join, basename } from 'path'
-import { homedir } from 'os'
-import { createDir, moveFile, writeFile, guardPath } from '../files/ops.js'
-
-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: /review /mkdir /mv /touch /models /sessions /session /clear /list /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
-  },
-  {
-    name: 'mkdir',
-    ns: 'default',
-    description: 'Create a folder — usage: /mkdir <path>',
-    execute: (args) => {
-      const p = args.trim()
-      if (!p) return 'Usage: /mkdir <path>'
-      createDir(guardPath(p))
-      return `created: ${p}`
-    },
-  },
-  {
-    name: 'mv',
-    ns: 'default',
-    description: 'Move or rename file/folder — usage: /mv <from> <to>',
-    execute: (args) => {
-      const parts = args.trim().split(/\s+/)
-      if (parts.length < 2) return 'Usage: /mv <from> <to>'
-      const [from, to] = parts
-      moveFile(guardPath(from), guardPath(to))
-      return `moved: ${from} → ${to}`
-    },
-  },
-  {
-    name: 'touch',
-    ns: 'default',
-    description: 'Create empty file — usage: /touch <path>',
-    execute: (args) => {
-      const p = args.trim()
-      if (!p) return 'Usage: /touch <path>'
-      writeFile(guardPath(p), '')
-      return `created: ${p}`
-    },
-  },
-]
-
-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

@@ -1,151 +0,0 @@
-import { readFile, writeFile, deleteFile, listFiles, createDir, moveFile, guardPath } from '../files/ops.js'
-import { existsSync } from 'fs'
-import { exec } from 'child_process'
-import { promisify } from 'util'
-
-const run = promisify(exec)
-const EXEC_TIMEOUT_MS = 30_000
-
-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(guardPath(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(guardPath(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: 'create_file',
-    description: 'Create a new file — fails if file already exists',
-    params: '{"path": "string", "content": "string"}',
-    execute: async ({ path, content }) => {
-      const safe = guardPath(path as string)
-      if (existsSync(safe)) throw new Error(`file already exists: ${path}`)
-      writeFile(safe, content as string)
-      return `created: ${path}`
-    },
-  },
-  {
-    name: 'edit_file',
-    description: 'Overwrite entire file — use only for new files or full rewrites',
-    params: '{"path": "string", "content": "string"}',
-    execute: async ({ path, content }) => {
-      writeFile(guardPath(path as string), content as string)
-      return `written: ${path}`
-    },
-  },
-  {
-    name: 'patch_file',
-    description: 'Replace an exact string in a file — use for targeted edits to existing files',
-    params: '{"path": "string", "old": "string", "new": "string"}',
-    execute: async ({ path, old: oldStr, new: newStr }) => {
-      const safe = guardPath(path as string)
-      const current = readFile(safe)
-      if (!current) throw new Error(`file not found or empty: ${path}`)
-      if (!current.includes(oldStr as string)) throw new Error(`old text not found in ${path}`)
-      const updated = current.replace(oldStr as string, newStr as string)
-      writeFile(safe, updated)
-      return `patched: ${path}`
-    },
-  },
-  {
-    name: 'delete_file',
-    description: 'Delete a file',
-    params: '{"path": "string"}',
-    execute: async ({ path }) => {
-      deleteFile(guardPath(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(), timeout: EXEC_TIMEOUT_MS })
-      return [stdout, stderr ? `stderr: ${stderr}` : ''].filter(Boolean).join('\n').trim()
-    },
-  },
-  {
-    name: 'create_folder',
-    description: 'Create a directory (and any missing parents)',
-    params: '{"path": "string"}',
-    execute: async ({ path }) => {
-      createDir(guardPath(path as string))
-      return `created: ${path}`
-    },
-  },
-  {
-    name: 'move_file',
-    description: 'Move or rename a file or directory',
-    params: '{"from": "string", "to": "string"}',
-    execute: async ({ from, to }) => {
-      moveFile(guardPath(from as string), guardPath(to as string))
-      return `moved: ${from} → ${to}`
-    },
-  },
-]
-
-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>
-
-Put file content in named blocks (never inside JSON — avoids escaping errors):
-
-For edit_file / create_file use <content> block:
-<tool_call>
-{"name": "edit_file", "args": {"path": "src/foo.ts"}}
-<content>
-full file content here
-</content>
-</tool_call>
-
-For patch_file use <old> and <new> blocks:
-<tool_call>
-{"name": "patch_file", "args": {"path": "src/foo.ts"}}
-<old>
-exact text to replace
-</old>
-<new>
-replacement text
-</new>
-</tool_call>
-
-Tools:
-${toolDocs}
-
-Rules:
-- To modify an existing file: use patch_file with the exact old text and new replacement — do NOT rewrite the whole file
-- To create a new file: use edit_file with full content in the <content> block
-- read_file before patch_file so you know the exact text to match
-- Never delete without confirming
-- Be concise
-- Output plain text only — never use markdown formatting in your responses
-- No headers (no #, ##), no bold (**text**), no italic (*text*), no bullet points with *, no horizontal rules (---)
-- No fenced code blocks with backticks in prose
-- Use plain indentation and labels for structure. This is a terminal, not a chat UI${extra}`
-}