miii-cli 0.2.1 → 0.2.2

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}`
-}