miii-cli 0.2.3 → 0.2.5

package/dist/init.js

@@ -1,11 +1,68 @@
 import { render } from 'ink';
 import React from 'react';
 import minimist from 'minimist';
+import { createRequire } from 'module';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
 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';
+const require = createRequire(import.meta.url);
+const UPDATE_CACHE = join(homedir(), '.config', 'miii', 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24h
+function semverGt(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const x = pa[i] ?? 0, y = pb[i] ?? 0;
+        if (x > y)
+            return true;
+        if (x < y)
+            return false;
+    }
+    return false;
+}
+function isLinkedInstall() {
+    try {
+        const bin = execSync('which miii', { encoding: 'utf-8' }).trim();
+        const resolved = execSync(`readlink "${bin}"`, { encoding: 'utf-8' }).trim();
+        return resolved.includes('node_modules') && !resolved.includes('npm/lib');
+    }
+    catch {
+        return false;
+    }
+}
+async function checkLatestVersion(current) {
+    // Return cached result if checked within 24h
+    try {
+        if (existsSync(UPDATE_CACHE)) {
+            const cache = JSON.parse(readFileSync(UPDATE_CACHE, 'utf-8'));
+            if (Date.now() - cache.ts < CHECK_INTERVAL_MS) {
+                return semverGt(cache.latest, current) ? cache.latest : undefined;
+            }
+        }
+    }
+    catch { }
+    try {
+        const res = await fetch('https://registry.npmjs.org/miii-cli/latest', { signal: AbortSignal.timeout(3000) });
+        if (!res.ok)
+            return undefined;
+        const data = await res.json();
+        const latest = data.version;
+        if (!latest)
+            return undefined;
+        // Cache result
+        mkdirSync(join(homedir(), '.config', 'miii'), { recursive: true });
+        writeFileSync(UPDATE_CACHE, JSON.stringify({ ts: Date.now(), latest }));
+        return semverGt(latest, current) ? latest : undefined;
+    }
+    catch { }
+    return undefined;
+}
 export async function lazyInit() {
     const argv = minimist(process.argv.slice(2), {
         string: ['model', 'url', 'provider', 'session'],
@@ -18,16 +75,21 @@ export async function lazyInit() {
         config.baseUrl = argv.url;
     if (argv.provider)
         config.provider = argv.provider;
+    const pkg = require('../package.json');
+    const currentVersion = pkg.version;
     if (config.provider === 'ollama') {
         await ensureOllama(config.baseUrl);
     }
     const skills = new SkillLoader();
-    await skills.loadAll();
+    // Run version check + skill load in parallel — don't block startup
+    const linked = isLinkedInstall();
+    const [, updateAvailable] = await Promise.all([
+        skills.loadAll(),
+        checkLatestVersion(currentVersion),
+    ]);
     // 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
+    welcome(config.provider, config.model, process.cwd(), currentVersion, updateAvailable, linked);
     const sessionName = argv.session || 'default';
-    const { waitUntilExit } = render(React.createElement(InputBar, { config, skills, cwd: process.cwd(), session: sessionName }), { exitOnCtrlC: false });
+    const { waitUntilExit } = render(React.createElement(InputBar, { config, skills, cwd: process.cwd(), session: sessionName, version: currentVersion }), { exitOnCtrlC: false });
     await waitUntilExit();
 }

package/dist/skills/loader.js

@@ -2,6 +2,11 @@ import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join, basename } from 'path';
 import { homedir } from 'os';
 import { createDir, moveFile, writeFile, guardPath } from '../files/ops.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const run = promisify(exec);
+export const MIII_HOME = join(homedir(), '.config', 'miii');
+const NPM_SKILLS_DIR = MIII_HOME;
 const builtin = [
     {
         name: 'caveman',
@@ -47,7 +52,7 @@ const builtin = [
         name: 'models',
         ns: 'default',
         description: 'Choose or pull Ollama models',
-        // execute handled specially in App.tsx before skill lookup
+        // execute handled specially in InputBar before skill lookup
     },
     {
         name: 'mkdir',
@@ -96,6 +101,7 @@ export class SkillLoader {
         }
     }
     async loadAll() {
+        // 1. Markdown skills from ~/.config/miii/skills/ and .miii/skills/
         const dirs = [
             join(homedir(), '.config', 'miii', 'skills'),
             join(process.cwd(), '.miii', 'skills'),
@@ -118,6 +124,64 @@ export class SkillLoader {
                 this.map.set(`custom:${name}`, skill);
             }
         }
+        // 2. npm skill packages: miii-skill-* installed in ~/.config/miii/node_modules/
+        const nmDir = join(NPM_SKILLS_DIR, 'node_modules');
+        if (existsSync(nmDir)) {
+            for (const pkg of readdirSync(nmDir)) {
+                if (!pkg.startsWith('miii-skill-'))
+                    continue;
+                const pkgDir = join(nmDir, pkg);
+                try {
+                    const pkgJson = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf-8'));
+                    const main = pkgJson.main ?? 'index.js';
+                    const entry = join(pkgDir, main);
+                    if (!existsSync(entry))
+                        continue;
+                    const mod = await import(entry);
+                    const exported = mod.default ?? mod.skill ?? mod.skills;
+                    const skillList = Array.isArray(exported) ? exported : [exported];
+                    for (const s of skillList) {
+                        if (!s?.name || !s?.description)
+                            continue;
+                        const ns = s.ns ?? 'npm';
+                        const skill = { ...s, ns };
+                        this.map.set(s.name, skill);
+                        this.map.set(`${ns}:${s.name}`, skill);
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    async installSkill(nameOrPkg) {
+        const pkg = nameOrPkg.includes('/') || nameOrPkg.startsWith('miii-skill-')
+            ? nameOrPkg
+            : `miii-skill-${nameOrPkg}`;
+        createDir(NPM_SKILLS_DIR);
+        const { stdout, stderr } = await run(`npm install --prefix ${JSON.stringify(NPM_SKILLS_DIR)} ${pkg}`);
+        const out = (stdout + stderr).trim();
+        // Reload newly installed skill
+        await this.loadAll();
+        return `installed ${pkg}\n${out}`;
+    }
+    async uninstallSkill(nameOrPkg) {
+        const pkg = nameOrPkg.includes('/') || nameOrPkg.startsWith('miii-skill-')
+            ? nameOrPkg
+            : `miii-skill-${nameOrPkg}`;
+        const { stdout, stderr } = await run(`npm uninstall --prefix ${JSON.stringify(NPM_SKILLS_DIR)} ${pkg}`);
+        const out = (stdout + stderr).trim();
+        // Remove from map
+        const shortName = pkg.replace(/^miii-skill-/, '');
+        this.map.delete(shortName);
+        this.map.delete(`npm:${shortName}`);
+        this.map.delete(pkg);
+        return `uninstalled ${pkg}\n${out}`;
+    }
+    listNpmSkills() {
+        const nmDir = join(NPM_SKILLS_DIR, 'node_modules');
+        if (!existsSync(nmDir))
+            return [];
+        return readdirSync(nmDir).filter(p => p.startsWith('miii-skill-'));
     }
     get(ref) {
         return this.map.get(ref);

package/dist/tavily/client.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const KEY_FILE = join(homedir(), '.config', 'miii', 'tavily.key');
+export function getTavilyKey() {
+    if (existsSync(KEY_FILE)) {
+        const k = readFileSync(KEY_FILE, 'utf-8').trim();
+        if (k)
+            return k;
+    }
+    return undefined;
+}
+export function saveTavilyKey(key) {
+    mkdirSync(join(homedir(), '.config', 'miii'), { recursive: true });
+    writeFileSync(KEY_FILE, key.trim(), { encoding: 'utf-8', mode: 0o600 });
+}
+async function post(path, body) {
+    const res = await fetch(`https://api.tavily.com${path}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Tavily API ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+export async function tavilySearch(opts) {
+    const data = await post('/search', {
+        api_key: opts.apiKey,
+        query: opts.query,
+        search_depth: opts.searchDepth ?? 'basic',
+        max_results: Math.min(opts.maxResults ?? 5, 10),
+        include_answer: opts.includeAnswer ?? true,
+        include_raw_content: false,
+        include_domains: opts.includeDomains ?? [],
+        exclude_domains: opts.excludeDomains ?? [],
+    });
+    const parts = [];
+    if (data.answer)
+        parts.push(`Answer: ${data.answer}\n`);
+    for (const r of data.results) {
+        parts.push(`[${r.title}] ${r.url}\n${r.content}`);
+    }
+    return parts.join('\n\n').trim() || '(no results)';
+}
+export async function tavilyExtract(opts) {
+    const data = await post('/extract', {
+        api_key: opts.apiKey,
+        urls: opts.urls.slice(0, 20),
+    });
+    const parts = [];
+    for (const r of data.results) {
+        const truncated = r.raw_content.length > 8000
+            ? r.raw_content.slice(0, 8000) + '\n…[truncated at 8k]'
+            : r.raw_content;
+        parts.push(`[${r.url}]\n${truncated}`);
+    }
+    if (data.failed_results?.length) {
+        parts.push(`Failed URLs: ${data.failed_results.map(r => r.url).join(', ')}`);
+    }
+    return parts.join('\n\n---\n\n').trim() || '(no content extracted)';
+}

package/dist/tools/index.js

@@ -3,6 +3,7 @@ import { existsSync } from 'fs';
 import { join } from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { getTavilyKey, tavilySearch, tavilyExtract } from '../tavily/client.js';
 const run = promisify(exec);
 const EXEC_TIMEOUT_MS = 30_000;
 export const tools = [
@@ -201,6 +202,36 @@ export const tools = [
             }
         },
     },
+    {
+        name: 'web_search',
+        description: 'Search the web using Tavily. Returns relevant results and a direct answer.',
+        params: '{"query": "string", "max_results": "number (optional, 1-10, default 5)", "search_depth": "string (optional: basic|advanced)", "include_domains": "string[] (optional)", "exclude_domains": "string[] (optional)"}',
+        execute: async ({ query, max_results, search_depth, include_domains, exclude_domains }) => {
+            const key = getTavilyKey();
+            if (!key)
+                throw new Error('Tavily API key not set — user must run /tavily-key <key> first');
+            return tavilySearch({
+                apiKey: key,
+                query: String(query),
+                maxResults: typeof max_results === 'number' ? max_results : undefined,
+                searchDepth: search_depth,
+                includeDomains: include_domains,
+                excludeDomains: exclude_domains,
+            });
+        },
+    },
+    {
+        name: 'web_extract',
+        description: 'Extract and scrape full content from one or more URLs using Tavily.',
+        params: '{"urls": "string[]"}',
+        execute: async ({ urls }) => {
+            const key = getTavilyKey();
+            if (!key)
+                throw new Error('Tavily API key not set — user must run /tavily-key <key> first');
+            const list = Array.isArray(urls) ? urls : [String(urls)];
+            return tavilyExtract({ apiKey: key, urls: list });
+        },
+    },
 ];
 export function getSystemPrompt(extra = '') {
     const toolDocs = tools.map(t => `- ${t.name}(${t.params}): ${t.description}`).join('\n');
@@ -246,8 +277,12 @@ Rules:
 - 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
+- NEVER show file content or code in your text response — always use edit_file, patch_file, or create_file tools to write code to files
+- If you want to show the user code, write it to the file with a tool call instead
+- No fenced code blocks (no \`\`\`). If you find yourself about to write a code block, use a tool call instead
 - Use plain indentation and labels for structure. This is a terminal, not a chat UI
 - After editing files that have tests, call run_tests to verify nothing broke
-- If run_tests fails, read the failing test output and fix the code, then run_tests again (max 3 retries)${extra}`;
+- If run_tests fails, read the failing test output and fix the code, then run_tests again (max 3 retries)
+- You have web_search and web_extract tools — use them whenever the user asks about anything requiring internet access, current information, documentation, library versions, news, or external URLs
+- NEVER say you cannot search the web — always call web_search instead${extra}`;
 }