miii-cli 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-cli",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "description": "Claude Code-level terminal workflows powered by your local models.",
   "license": "MIT",
@@ -24,6 +24,11 @@
     "terminal",
     "local-ai"
   ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "bin": {
     "miii": "dist/index.js"
   },

package/.claude/settings.local.json

@@ -1,28 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git -C /Users/akshay/Desktop/essentials/akshay-workspace/miii-cli status)",
-      "Bash(npm install *)",
-      "Bash(npx tsc *)",
-      "Bash(node --input-type=module)",
-      "Bash(chmod +x dist/index.js)",
-      "Bash(node dist/index.js --help)",
-      "Bash(node dist/index.js)",
-      "Bash(chmod +x install.sh)",
-      "Bash(npm whoami *)",
-      "Bash(npm run *)",
-      "Bash(npm publish *)",
-      "Bash(npm pkg *)",
-      "Bash(npm version *)",
-      "Bash(chmod +x *)",
-      "Bash(git grep *)",
-      "Bash(npm link *)",
-      "Bash(node -e \"const {appendFileSync} = require\\('fs'\\); appendFileSync\\('/tmp/miii-test.log', 'test\\\\n'\\); console.log\\('ok'\\)\")",
-      "Read(//tmp/**)",
-      "Read(//private/tmp/**)",
-      "Read(//Users/akshay/**)",
-      "Bash(tsx --version)",
-      "Bash(node -e ' *)"
-    ]
-  }
-}

package/CONTRIBUTING.md

@@ -1,55 +0,0 @@
-# Contributing to miii-cli
-
-We welcome contributions! miii-cli is a community-driven project, and your help is invaluable whether you're fixing a bug, adding a feature, or improving documentation.
-
----
-
-### 🚀 How to Contribute
-
-1.  **Fork** the repository.
-2.  **Clone** your fork locally.
-3.  **Create a new branch** (`git checkout -b feature/my-awesome-feature`).
-4.  **Commit** your changes and **Push** to the branch.
-5.  **Open a Pull Request (PR)** against the `main` branch.
-
-### 🤝 Guidelines
-
-*   **Code Style:** Please follow standard JavaScript/TypeScript best practices.
-*   **Testing:** All new features must include accompanying unit or integration tests.
-*   **Documentation:** If you change an API or add complex logic, please update the relevant documentation files.
-
-### 📝 Workflow
-
-*   **Bugs:** If you find a bug, please report it on the Issues page with a clear reproduction guide and expected behavior.
-*   **Features:** Before starting a large feature, please open an Issue to discuss the scope and design with the core team.
-
-### 🐛 Bug Reporting
-
-When reporting a bug, please include:
-
-1.  **Title:** A concise summary of the issue.
-2.  **Environment:** (e.g., Node.js version, OS, browser)
-3.  **Steps to Reproduce:** A numbered list of exact steps to trigger the bug.
-4.  **Expected Result:** What should have happened.
-5.  **Actual Result:** What actually happened.
-
-***
-
-### 🛠 Development Setup
-
-To work on miii-cli locally, please ensure you have the necessary dependencies installed.
-
-1.  **Install Dependencies:**
-    `npm install`
-
-2.  **Common Commands:**
-    We use a Makefile to streamline common tasks:
-
-    Development/Live Run:   `make dev` (Runs the application in development mode)
-    Build Project:         `make build` (Compiles the TypeScript source code)
-    Install Globally:      `make install` (Links the project using `npm link`)
-    Clean Build:           `make clean` (Removes compiled output)
-
-### 🧪 Testing
-
-When writing tests, please ensure they cover both the happy path and expected edge cases.

package/Makefile

@@ -1,13 +0,0 @@
-.PHONY: dev build install clean
-
-dev:
-	tsx src/index.ts
-
-build:
-	tsc
-
-install: build
-	npm link
-
-clean:
-	rm -rf dist

package/install.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-set -e
-npm install
-npm run build
-npm link
-echo "miii installed. Run: miii"

package/src/config.ts

@@ -1,32 +0,0 @@
-import { readFileSync, existsSync } from 'fs'
-import { homedir } from 'os'
-import { join } from 'path'
-import type { Config } from './types.js'
-
-const defaults: Config = {
-  model: 'llama3.2',
-  provider: 'ollama',
-  baseUrl: 'http://localhost:11434',
-}
-
-const ALLOWED_KEYS = new Set<keyof Config>(['model', 'provider', 'baseUrl', 'systemPrompt', 'apiKey'])
-
-export function loadConfig(): Config {
-  const candidates = [
-    join(process.cwd(), '.miii.json'),
-    join(homedir(), '.config', 'miii', 'config.json'),
-  ]
-  for (const p of candidates) {
-    if (existsSync(p)) {
-      try {
-        const raw: Record<string, unknown> = JSON.parse(readFileSync(p, 'utf-8'))
-        const safe: Partial<Config> = {}
-        for (const key of ALLOWED_KEYS) {
-          if (key in raw) (safe as Record<string, unknown>)[key] = raw[key]
-        }
-        return { ...defaults, ...safe }
-      } catch {}
-    }
-  }
-  return { ...defaults }
-}

package/src/files/ops.ts

@@ -1,89 +0,0 @@
-import {
-  readFileSync, writeFileSync, unlinkSync,
-  mkdirSync, readdirSync, statSync, existsSync, renameSync,
-} from 'fs'
-import { join, dirname, relative, extname, resolve, sep } from 'path'
-
-export function guardPath(p: string, base = process.cwd()): string {
-  const abs = resolve(base, p)
-  const root = resolve(base)
-  if (abs !== root && !abs.startsWith(root + sep)) {
-    throw new Error(`path outside working directory: ${p}`)
-  }
-  return abs
-}
-
-const SKIP_DIRS = new Set([
-  'node_modules', 'dist', 'build', '.git', '.next', '.nuxt', '.svelte-kit',
-  'out', '__pycache__', '.cache', 'coverage', '.nyc_output', 'vendor',
-  'target', '.turbo', '.vercel', 'generated', '.gradle', '.expo',
-  'bin', 'obj', '.idea', '.vscode', 'tmp', 'temp', 'logs',
-])
-
-const SKIP_EXTS = new Set([
-  '.map', '.lock',
-  '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.bmp', '.tiff',
-  '.mp4', '.mp3', '.wav', '.ogg', '.pdf',
-  '.zip', '.tar', '.gz', '.rar', '.7z',
-  '.exe', '.dll', '.so', '.dylib', '.wasm', '.class', '.pyc',
-  '.ttf', '.woff', '.woff2', '.eot',
-])
-
-const SKIP_NAMES = new Set([
-  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'Cargo.lock',
-  'poetry.lock', 'Gemfile.lock', 'composer.lock',
-  '.DS_Store', 'Thumbs.db', '.env.local', 'LICENSE', 'LICENSE.md',
-])
-
-export function readFile(p: string): string {
-  if (!existsSync(p)) return ''
-  return readFileSync(p, 'utf-8')
-}
-
-export function writeFile(p: string, content: string): void {
-  mkdirSync(dirname(p), { recursive: true })
-  writeFileSync(p, content, 'utf-8')
-}
-
-export function deleteFile(p: string): void {
-  unlinkSync(p)
-}
-
-export function createDir(p: string): void {
-  mkdirSync(p, { recursive: true })
-}
-
-export function moveFile(from: string, to: string): void {
-  mkdirSync(dirname(to), { recursive: true })
-  renameSync(from, to)
-}
-
-export interface FileEntry {
-  name: string
-  path: string
-  rel: string
-  type: 'file' | 'dir'
-  size?: number
-}
-
-export function listFiles(dir: string, recursive = false, cwd = process.cwd()): FileEntry[] {
-  if (!existsSync(dir)) return []
-  const entries: FileEntry[] = []
-  for (const name of readdirSync(dir)) {
-    if (name.startsWith('.')) continue
-    if (SKIP_NAMES.has(name)) continue
-    if (SKIP_DIRS.has(name)) continue
-    const ext = extname(name)
-    if (SKIP_EXTS.has(ext)) continue
-    if (name.endsWith('.d.ts') || name.endsWith('.js.map')) continue
-    let stat
-    try { stat = statSync(join(dir, name)) } catch { continue }
-    const full = join(dir, name)
-    const type = stat.isDirectory() ? 'dir' : 'file'
-    entries.push({ name, path: full, rel: relative(cwd, full), type, size: stat.isFile() ? stat.size : undefined })
-    if (recursive && type === 'dir') {
-      entries.push(...listFiles(full, true, cwd))
-    }
-  }
-  return entries
-}

package/src/index.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-// Minimal entry — heavy imports lazy-loaded
-async function main() {
-  const { lazyInit } = await import('./init.js')
-  await lazyInit()
-}
-
-main().catch(err => {
-  process.stderr.write(`fatal: ${err.message}\n`)
-  process.exit(1)
-})

package/src/init.ts

@@ -1,41 +0,0 @@
-import { render } from 'ink'
-import React from 'react'
-import minimist from 'minimist'
-import { loadConfig } from './config.js'
-import { SkillLoader } from './skills/loader.js'
-import { InputBar } from './tui/InputBar.js'
-import { welcome } from './tui/printer.js'
-import { ensureOllama } from './llm/ollama.js'
-
-export async function lazyInit(): Promise<void> {
-  const argv = minimist(process.argv.slice(2), {
-    string: ['model', 'url', 'provider', 'session'],
-    alias: { m: 'model', u: 'url', p: 'provider', s: 'session' },
-  })
-
-  const config = loadConfig()
-  if (argv.model) config.model = argv.model
-  if (argv.url) config.baseUrl = argv.url
-  if (argv.provider) config.provider = argv.provider as typeof config.provider
-
-  if (config.provider === 'ollama') {
-    await ensureOllama(config.baseUrl)
-  }
-
-  const skills = new SkillLoader()
-  await skills.loadAll()
-
-  // Print welcome banner to scrollback BEFORE Ink starts
-  welcome(config.provider, config.model, process.cwd())
-
-  // Ink renders ONLY the input bar (small footprint at bottom)
-  // patchConsole: true (default) ensures console.log output appears above Ink
-  const sessionName = (argv.session as string) || 'default'
-
-  const { waitUntilExit } = render(
-    React.createElement(InputBar, { config, skills, cwd: process.cwd(), session: sessionName }),
-    { exitOnCtrlC: false }
-  )
-
-  await waitUntilExit()
-}

package/src/llm/ollama.ts

@@ -1,110 +0,0 @@
-import { execSync, spawn } from 'child_process'
-
-export interface OllamaModel {
-  name: string
-  size: number
-  modified_at: string
-  digest?: string
-}
-
-export async function listModels(baseUrl: string): Promise<OllamaModel[]> {
-  const res = await fetch(`${baseUrl}/api/tags`)
-  if (!res.ok) throw new Error(`Ollama ${res.status}: ${await res.text()}`)
-  const data = (await res.json()) as { models?: OllamaModel[] }
-  return data.models ?? []
-}
-
-export async function pullModel(
-  baseUrl: string,
-  name: string,
-  onProgress: (status: string, pct: number | undefined) => void,
-  signal?: AbortSignal,
-): Promise<void> {
-  const res = await fetch(`${baseUrl}/api/pull`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ name, stream: true }),
-    signal,
-  })
-  if (!res.ok) throw new Error(`pull failed: ${res.status} ${await res.text()}`)
-
-  const reader = res.body!.getReader()
-  const dec = new TextDecoder()
-  let buf = ''
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) break
-      buf += dec.decode(value, { stream: true })
-      const lines = buf.split('\n')
-      buf = lines.pop() ?? ''
-      for (const line of lines) {
-        if (!line.trim()) continue
-        try {
-          const obj = JSON.parse(line) as { status?: string; completed?: number; total?: number }
-          const pct = obj.total ? Math.round(((obj.completed ?? 0) / obj.total) * 100) : undefined
-          onProgress(obj.status ?? '', pct)
-        } catch {}
-      }
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-export async function ensureOllama(baseUrl: string): Promise<void> {
-  if (await isReachable(baseUrl)) return
-
-  if (!isBinaryInstalled()) {
-    process.stderr.write('\nOllama not found. Install it:\n\n')
-    if (process.platform === 'darwin') {
-      process.stderr.write('  brew install ollama\n')
-      process.stderr.write('  — or download: https://ollama.ai/download\n')
-    } else if (process.platform === 'linux') {
-      process.stderr.write('  curl -fsSL https://ollama.ai/install.sh | sh\n')
-    } else {
-      process.stderr.write('  https://ollama.ai/download\n')
-    }
-    process.stderr.write('\nThen run: ollama serve\n\n')
-    process.exit(1)
-  }
-
-  process.stderr.write('Ollama not running — starting ollama serve...\n')
-  spawn('ollama', ['serve'], { detached: true, stdio: 'ignore' }).unref()
-
-  for (let i = 0; i < 12; i++) {
-    await new Promise(r => setTimeout(r, 500))
-    if (await isReachable(baseUrl)) {
-      process.stderr.write('Ollama ready.\n')
-      return
-    }
-  }
-
-  process.stderr.write('Could not start Ollama. Run manually: ollama serve\n')
-  process.exit(1)
-}
-
-async function isReachable(baseUrl: string): Promise<boolean> {
-  try {
-    const res = await fetch(`${baseUrl}/api/tags`, { signal: AbortSignal.timeout(2000) })
-    return res.ok
-  } catch {
-    return false
-  }
-}
-
-function isBinaryInstalled(): boolean {
-  try {
-    execSync(process.platform === 'win32' ? 'where ollama' : 'which ollama', { stdio: 'ignore' })
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function fmtSize(bytes: number): string {
-  if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)}GB`
-  if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(0)}MB`
-  return `${(bytes / 1e3).toFixed(0)}KB`
-}

package/src/llm/stream.ts

@@ -1,55 +0,0 @@
-import type { ChatMessage } from '../types.js'
-
-export interface ChatConfig {
-  provider: 'ollama' | 'openai-compat'
-  model: string
-  baseUrl: string
-  apiKey?: string
-  messages: ChatMessage[]
-  signal?: AbortSignal
-  onDone: (fullText: string) => void | Promise<void>
-  onError: (err: Error) => void
-}
-
-export async function chat(cfg: ChatConfig): Promise<void> {
-  if (cfg.provider === 'openai-compat') return chatOpenAI(cfg)
-  return chatOllama(cfg)
-}
-
-async function chatOllama(cfg: ChatConfig): Promise<void> {
-  const { model, messages, baseUrl, signal, onDone, onError } = cfg
-  try {
-    const res = await fetch(`${baseUrl}/api/chat`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ model, messages, stream: false }),
-      signal,
-    })
-    if (!res.ok) { onError(new Error(`Ollama ${res.status}: ${await res.text()}`)); return }
-    const obj = await res.json()
-    await onDone(obj?.message?.content ?? '')
-  } catch (err) {
-    if ((err as Error)?.name !== 'AbortError') onError(toError(err))
-  }
-}
-
-async function chatOpenAI(cfg: ChatConfig): Promise<void> {
-  const { model, messages, baseUrl, apiKey, signal, onDone, onError } = cfg
-  try {
-    const res = await fetch(`${baseUrl}/v1/chat/completions`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey ?? 'local'}` },
-      body: JSON.stringify({ model, messages }),
-      signal,
-    })
-    if (!res.ok) { onError(new Error(`LLM ${res.status}: ${await res.text()}`)); return }
-    const obj = await res.json()
-    await onDone(obj?.choices?.[0]?.message?.content ?? '')
-  } catch (err) {
-    if ((err as Error)?.name !== 'AbortError') onError(toError(err))
-  }
-}
-
-function toError(e: unknown): Error {
-  return e instanceof Error ? e : new Error(String(e))
-}

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