@hmharness/cli 0.7.0 → 0.8.0

package/dist/main.js

@@ -680,6 +680,28 @@ flags:
         }
         return;
     }
+    if (cmd === 'eval') {
+        // V2 M2: the Evaluator surface - hard evidence outranks LLM judgment.
+        await initHome();
+        const { allEvaluators } = await import('@hmharness/evaluation');
+        const { listCases } = await import('@hmharness/evolution');
+        const cases = await listCases(homeDir());
+        stdout.write('evaluators:\n' + allEvaluators.map((e) => '  ' + e.id.padEnd(16) + DIM('rank ' + e.evidenceKind) + '  ' + e.description.slice(0, 70)).join('\n') + '\n');
+        stdout.write('bench cases: ' + cases.length + ' (train ' + cases.filter((c) => !c.holdout).length + ' / holdout ' + cases.filter((c) => c.holdout).length + ')\n');
+        return;
+    }
+    if (cmd === 'capability') {
+        // V2 M4: capability manifests - declared risk/permissions per tool.
+        await initHome();
+        const { capabilityReport, authorize, buildRegistry } = await import('@hmharness/agent');
+        const { reg } = await buildRegistry({ announce: false });
+        const mode = rest.includes('--lockdown') ? 'lockdown' : 'standard';
+        for (const m of capabilityReport(reg)) {
+            const d = authorize(m, mode);
+            stdout.write('  ' + (d.allow ? GREEN('allow') : RED('DENY ')) + '  ' + m.risk.padEnd(8) + m.id.padEnd(22) + DIM(m.permissions.join(',')) + '\n');
+        }
+        return;
+    }
     if (cmd === 'tui') {
         await initHome();
         // tui(yes, noWeb): inside the TTY check the TUI auto-links the web UI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/cli",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "hmharness command line: one-shot tasks, an interactive REPL, a fullscreen TUI, the web frontend, and direct tool invocation.",
   "type": "module",
   "main": "dist/main.js",
@@ -43,12 +43,13 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@hmharness/kernel": "0.7.0",
+    "@hmharness/kernel": "0.8.0",
     "@hmharness/observability": "0.7.0",
-    "@hmharness/evolution": "0.7.0",
-    "@hmharness/domain-harmony": "0.7.0",
-    "@hmharness/domain-ops": "0.7.0",
-    "@hmharness/agent": "0.7.0",
-    "@hmharness/web": "0.7.0"
+    "@hmharness/evolution": "0.8.0",
+    "@hmharness/domain-harmony": "0.8.0",
+    "@hmharness/domain-ops": "0.8.0",
+    "@hmharness/agent": "0.8.0",
+    "@hmharness/evaluation": "0.8.0",
+    "@hmharness/web": "0.8.0"
   }
 }

package/dist/prompt.d.ts

@@ -1,7 +0,0 @@
-export declare function buildSystemPrompt(opts: {
-    cwd: string;
-    memory: string;
-    skills: string;
-    insights: string;
-    model: string;
-}): string;

package/dist/prompt.js

@@ -1,14 +0,0 @@
-export function buildSystemPrompt(opts) {
-    const parts = [];
-    parts.push(`You are hmh, a coding agent powered by ${opts.model}, running on hmharness - a self-evolving agent framework designed for the full HarmonyOS development lifecycle. Working directory: ${opts.cwd}.`, '', 'Reply in the language the user writes in (Chinese in, Chinese out).', '', 'HarmonyOS development is your home domain: DevEco Studio toolchain, hvigor builds, ohpm packages, hdc devices, ArkTS/ArkUI, OpenHarmony and Cangjie. When a task touches it, prefer the harmony_* tools and precise toolchain knowledge.', '', 'Working style: read before writing; prefer small focused commands; verify results; state tradeoffs briefly. For risky operations (deleting, overwriting, publishing) say what will happen first.');
-    if (opts.memory.trim()) {
-        parts.push('', '## Long-term memory', opts.memory.trim());
-    }
-    if (opts.skills.trim()) {
-        parts.push('', '## Skill library', 'Read a skill file with read_file before applying it the first time.', opts.skills.trim());
-    }
-    if (opts.insights.trim()) {
-        parts.push('', '## Recent session outcomes (what worked / what failed)', opts.insights.trim());
-    }
-    return parts.join('\n');
-}

package/dist/runner.d.ts

@@ -1,68 +0,0 @@
-/**
- * @hmh/cli - runner
- * The shared agent-task execution layer. CLI maps its events to terminal
- * output; the web frontend maps them to SSE - one behavior, two frontends.
- * Also owns the native registry factory (spawn_agent recursion) and the
- * approval gate construction.
- */
-import { Registry, type ChatMessage, type DeltaKind, type HmhConfig, type LoopApproval, type LoopResult, type McpClient, type McpServerConfig, type McpServerImport, type ToolContext } from '@hmh/kernel';
-import * as readline from 'node:readline/promises';
-import { type SpawnBase } from './spawn.ts';
-/** Flatten the config.json shape into the runtime discriminated union. */
-export declare function toServerConfig(c: McpServerImport): McpServerConfig;
-/**
- * Current spawn base, set per task so a long-lived registry (REPL, web
- * server) always routes sub-agents to the CURRENT session and gate.
- */
-export declare const spawnBase: {
-    current?: SpawnBase;
-};
-export declare function nativeRegistry(depth: number): Registry;
-export declare function buildRegistry(opts?: {
-    mcp?: boolean;
-    announce?: boolean;
-}): Promise<{
-    reg: Registry;
-    clients: McpClient[];
-}>;
-/** Retrieval-based context pack: task-relevant memories, not the whole file. */
-export declare function contextPack(task: string): Promise<{
-    memory: string;
-    skills: string;
-    insights: string;
-}>;
-/**
- * Terminal approval gate: auto mode passes everything; a TTY gets a y/N
- * prompt (reusing a caller-provided readline); a pipe gets a safe deny.
- * The kernel loop denies by default when no gate is wired at all.
- */
-export declare function makeApproval(cfg: HmhConfig, yes: boolean, sharedRl?: readline.Interface): LoopApproval;
-export interface RunnerEvents {
-    onLine?(line: string): void;
-    onDelta?(kind: DeltaKind, chunk: string): void;
-    onToolCall?(name: string, args: Record<string, unknown>): void;
-    onToolResult?(name: string, output: string, isError: boolean): void;
-    onApproval?(name: string, args: Record<string, unknown>, granted: boolean): void;
-    onFinal?(r: {
-        text: string;
-        turns: number;
-        toolUses: number;
-        sessionId: string;
-    }): void;
-}
-export interface AgentTaskOptions {
-    task: string;
-    registry: Registry;
-    cfg?: HmhConfig;
-    ctx?: ToolContext;
-    yes?: boolean;
-    /** Overrides the terminal gate (web supplies a remote one). */
-    approvalAsk?: LoopApproval['ask'];
-    resumeMessages?: ChatMessage[];
-    events?: RunnerEvents;
-}
-/** Run one full agent task end-to-end; audit + insight recording included. */
-export declare function runAgentTask(opts: AgentTaskOptions): Promise<LoopResult & {
-    sessionId: string;
-    toolsUsed: string[];
-}>;

package/dist/runner.js

@@ -1,179 +0,0 @@
-/**
- * @hmh/cli - runner
- * The shared agent-task execution layer. CLI maps its events to terminal
- * output; the web frontend maps them to SSE - one behavior, two frontends.
- * Also owns the native registry factory (spawn_agent recursion) and the
- * approval gate construction.
- */
-import { homeDir, loadConfig, mcpServerTools, Registry, runLoop, Session, } from '@hmh/kernel';
-import { listSkills, recentInsights, recordInsight, retrieveMemory, skillsToPrompt } from '@hmh/evolution';
-import { harmonyTools } from '@hmh/domain-harmony';
-import * as readline from 'node:readline/promises';
-import { stdin } from 'node:process';
-import { baseTools } from "./tools.js";
-import { buildSystemPrompt } from "./prompt.js";
-import { makeSpawnTool, MAX_SPAWN_DEPTH } from "./spawn.js";
-/** Flatten the config.json shape into the runtime discriminated union. */
-export function toServerConfig(c) {
-    if (c.type === 'http')
-        return { type: 'http', url: c.url ?? '', headers: c.headers, trusted: c.trusted };
-    return { type: 'stdio', command: c.command ?? '', args: c.args, env: c.env, trusted: c.trusted };
-}
-/**
- * Current spawn base, set per task so a long-lived registry (REPL, web
- * server) always routes sub-agents to the CURRENT session and gate.
- */
-export const spawnBase = {};
-export function nativeRegistry(depth) {
-    const reg = new Registry();
-    reg.registerAll(baseTools).registerAll(harmonyTools);
-    if (depth < MAX_SPAWN_DEPTH) {
-        reg.register(makeSpawnTool({
-            depth,
-            getBase: () => spawnBase.current ?? {
-                provider: { baseUrl: '', apiKey: '', model: '' },
-                ctx: { cwd: process.cwd(), home: homeDir() },
-            },
-            buildChildRegistry: nativeRegistry,
-        }));
-    }
-    return reg;
-}
-export async function buildRegistry(opts = {}) {
-    const reg = nativeRegistry(0);
-    const clients = [];
-    if (opts.mcp !== false) {
-        const cfg = await loadConfig();
-        const servers = Object.entries(cfg.mcpServers ?? {});
-        if (servers.length > 0) {
-            await Promise.all(servers.map(async ([name, raw]) => {
-                try {
-                    const { client, tools } = await mcpServerTools(name, toServerConfig(raw));
-                    for (const t of tools) {
-                        try {
-                            reg.register(t);
-                        }
-                        catch {
-                            /* name collision after sanitization - first server wins */
-                        }
-                    }
-                    clients.push(client);
-                    if (opts.announce !== false)
-                        console.log(`  [mcp] ${name}: ${tools.length} tools attached`);
-                }
-                catch (err) {
-                    if (opts.announce !== false)
-                        console.log(`  [mcp] ${name}: unavailable (${String(err).slice(0, 140)})`);
-                }
-            }));
-        }
-    }
-    return { reg, clients };
-}
-/** Retrieval-based context pack: task-relevant memories, not the whole file. */
-export async function contextPack(task) {
-    const home = homeDir();
-    const [memory, skills, insights] = await Promise.all([
-        retrieveMemory(home, task),
-        listSkills(home),
-        recentInsights(home),
-    ]);
-    return { memory, skills: skillsToPrompt(skills), insights };
-}
-/**
- * Terminal approval gate: auto mode passes everything; a TTY gets a y/N
- * prompt (reusing a caller-provided readline); a pipe gets a safe deny.
- * The kernel loop denies by default when no gate is wired at all.
- */
-export function makeApproval(cfg, yes, sharedRl) {
-    return {
-        async ask(toolName, args) {
-            if (yes || cfg.approval === 'auto')
-                return true;
-            const brief = JSON.stringify(args).slice(0, 120);
-            if (!stdin.isTTY) {
-                process.stdout.write(`\x1b[33m  [approval] ${toolName} ${brief} — denied (no TTY; use --yes to allow)\x1b[0m\n`);
-                return false;
-            }
-            const rl = sharedRl ?? readline.createInterface({ input: stdin, output: process.stdout });
-            let answer;
-            try {
-                answer = (await rl.question(`\x1b[33m  [approval] ${toolName} ${brief} — run it? [y/N] \x1b[0m`)).trim().toLowerCase();
-            }
-            finally {
-                if (!sharedRl)
-                    rl.close();
-            }
-            return answer === 'y' || answer === 'yes';
-        },
-    };
-}
-/** Run one full agent task end-to-end; audit + insight recording included. */
-export async function runAgentTask(opts) {
-    const cfg = opts.cfg ?? (await loadConfig());
-    const ctx = opts.ctx ?? { cwd: process.cwd(), home: homeDir() };
-    const events = opts.events ?? {};
-    const pack = await contextPack(opts.task);
-    const system = buildSystemPrompt({
-        cwd: ctx.cwd,
-        memory: pack.memory,
-        skills: pack.skills,
-        insights: pack.insights,
-        model: cfg.provider.model,
-    });
-    const session = new Session(ctx.home, ctx.cwd, cfg.provider.model);
-    await session.user(opts.task);
-    const approval = opts.approvalAsk ? { ask: opts.approvalAsk } : makeApproval(cfg, opts.yes === true);
-    spawnBase.current = {
-        provider: cfg.provider,
-        ctx,
-        approval,
-        session,
-        onLine: (l) => events.onLine?.(l),
-    };
-    const messages = [
-        { role: 'system', content: system },
-        ...(opts.resumeMessages ?? []),
-        { role: 'user', content: opts.task },
-    ];
-    const toolsUsed = [];
-    const result = await runLoop({
-        provider: cfg.provider,
-        registry: opts.registry,
-        messages,
-        ctx,
-        maxTurns: cfg.maxTurns,
-        maxContextChars: cfg.maxContextChars,
-        approval: spawnBase.current.approval,
-        events: {
-            onDelta: (kind, chunk) => events.onDelta?.(kind, chunk),
-            onToolCall: (name, args) => {
-                toolsUsed.push(name);
-                events.onToolCall?.(name, args);
-            },
-            onToolResult: (name, output, isError) => {
-                void session.tool(name, output, isError);
-                events.onToolResult?.(name, output, isError);
-            },
-            onApproval: (name, args, granted) => {
-                void session.approval(name, granted);
-                events.onApproval?.(name, args, granted);
-            },
-            onAssistant: async (m) => {
-                await session.assistant(m.content ?? null, m.tool_calls);
-            },
-        },
-    });
-    await session.final(result.text, result.turns, result.toolUses);
-    await recordInsight(ctx.home, {
-        time: new Date().toISOString(),
-        session: session.id,
-        task: opts.task.slice(0, 120),
-        outcome: result.turns >= cfg.maxTurns ? 'turn-budget' : 'ok',
-        turns: result.turns,
-        toolUses: result.toolUses,
-        toolsUsed: [...new Set(toolsUsed)],
-    });
-    events.onFinal?.({ text: result.text, turns: result.turns, toolUses: result.toolUses, sessionId: session.id });
-    return { ...result, sessionId: session.id, toolsUsed: [...new Set(toolsUsed)] };
-}

package/dist/spawn.d.ts

@@ -1,29 +0,0 @@
-/**
- * @hmh/cli - spawn
- * The sub-agent tool: run a nested agent loop with a FRESH context on a
- * self-contained subtask and return its final answer. Children share the
- * tool registry (minus MCP - children stay fast and deterministic) and the
- * approval gate, but never the parent's conversation - context isolation
- * is the point. Depth-capped so a confused model can't fork-bomb itself.
- */
-import { type Session, type LoopApproval, type Registry, type Tool } from '@hmh/kernel';
-export declare const MAX_SPAWN_DEPTH = 2;
-export interface SpawnBase {
-    provider: import('@hmh/kernel').ProviderConfig;
-    ctx: import('@hmh/kernel').ToolContext;
-    approval?: LoopApproval;
-    session?: Session;
-    /** Bubbled tool traffic for display: `[sub1] list_dir {...}`. */
-    onLine?(line: string): void;
-}
-/**
- * Resolved lazily at each spawn so a long-lived REPL registry always sees the
- * CURRENT task's session/approval, not the one from when it was built.
- */
-export interface SpawnDeps {
-    depth: number;
-    getBase(): SpawnBase;
-    /** Build the registry for a child at the given depth (no spawn at the cap). */
-    buildChildRegistry(depth: number): Registry;
-}
-export declare function makeSpawnTool(deps: SpawnDeps): Tool;

package/dist/spawn.js

@@ -1,64 +0,0 @@
-/**
- * @hmh/cli - spawn
- * The sub-agent tool: run a nested agent loop with a FRESH context on a
- * self-contained subtask and return its final answer. Children share the
- * tool registry (minus MCP - children stay fast and deterministic) and the
- * approval gate, but never the parent's conversation - context isolation
- * is the point. Depth-capped so a confused model can't fork-bomb itself.
- */
-import { runLoop } from '@hmh/kernel';
-export const MAX_SPAWN_DEPTH = 2;
-export function makeSpawnTool(deps) {
-    return {
-        name: 'spawn_agent',
-        description: 'Run a sub-agent with a fresh context on a self-contained subtask (e.g. "explore the project layout and report module names", "find which file defines X"). Returns the sub-agent\'s final answer. The sub-agent has the same tools but NO conversation history and no MCP tools - include every detail it needs in the task. Use it to keep this conversation small: delegate exploration and focused lookups.',
-        parameters: {
-            type: 'object',
-            properties: {
-                task: { type: 'string', description: 'complete, self-contained instructions for the sub-agent' },
-                max_turns: { type: 'number', description: 'turn budget for the sub-agent (default 8, max 12)' },
-            },
-            required: ['task'],
-        },
-        async execute(args) {
-            const base = deps.getBase();
-            if (deps.depth >= MAX_SPAWN_DEPTH) {
-                return { output: `spawn depth cap (${MAX_SPAWN_DEPTH}) reached. Do the work directly instead.`, isError: true };
-            }
-            const task = String(args.task ?? '').trim();
-            if (!task)
-                return { output: 'spawn_agent requires a non-empty task.', isError: true };
-            const childDepth = deps.depth + 1;
-            const tag = `sub${childDepth}`;
-            const maxTurns = Math.min(Math.max(Number(args.max_turns ?? 8), 1), 12);
-            const registry = deps.buildChildRegistry(childDepth);
-            const system = [
-                `You are a hmh sub-agent (depth ${childDepth}). You have no conversation history beyond this task.`,
-                'Do exactly what the task asks, use tools as needed, verify before answering, and reply with a concise result (the caller only sees your final answer).',
-            ].join('\n');
-            base.onLine?.(`[${tag}] start: ${task.slice(0, 80)}`);
-            const result = await runLoop({
-                provider: base.provider,
-                registry,
-                messages: [
-                    { role: 'system', content: system },
-                    { role: 'user', content: task },
-                ],
-                ctx: base.ctx,
-                maxTurns,
-                approval: base.approval,
-                events: {
-                    onToolCall: (name, a) => base.onLine?.(`[${tag}] ${name} ${JSON.stringify(a).slice(0, 80)}`),
-                    onToolResult: (name, output, isError) => {
-                        void base.session?.tool(`${tag}>${name}`, output, isError);
-                        if (isError)
-                            base.onLine?.(`[${tag}] ${name} ERROR: ${output.slice(0, 100)}`);
-                    },
-                },
-            });
-            const text = result.text || '(sub-agent returned empty output)';
-            base.onLine?.(`[${tag}] done (${result.turns} turns, ${result.toolUses} tool uses)`);
-            return { output: text.length > 20_000 ? text.slice(0, 20_000) + '\n...[truncated]' : text };
-        },
-    };
-}

package/dist/tools.d.ts

@@ -1,7 +0,0 @@
-import type { Tool } from '@hmh/kernel';
-export declare const readFileTool: Tool;
-export declare const writeFileTool: Tool;
-export declare const listDirTool: Tool;
-export declare const runCommandTool: Tool;
-export declare const rememberTool: Tool;
-export declare const baseTools: Tool[];

package/dist/tools.js

@@ -1,137 +0,0 @@
-/**
- * @hmh/cli - base tools
- * The general coding-agent toolset: read, write, list, and a guarded shell
- * runner. Deny-first guard on obviously destructive one-liners; the real
- * sandbox/approval stack is a Phase 1 kernel feature.
- */
-import { exec } from 'node:child_process';
-import { readFile, readdir, writeFile } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
-import { promisify } from 'node:util';
-const execCb = promisify(exec);
-const DENY_PATTERNS = [
-    { re: /rm\s+-rf?\s+[/~C:\\]|format\s+[a-z]:|del\s+\/[sq]/i, why: 'recursive delete of a root/home path' },
-    { re: /shutdown|restart\s+computer|taskkill\s+\/f\s+\/im\s+explorer/i, why: 'system power/shell action' },
-    { re: /reg\s+(delete|add).*(Run|CurrentVersion)/i, why: 'autostart registry mutation' },
-];
-function safePath(p, cwd) {
-    return isAbsolute(p) ? p : resolve(cwd, p);
-}
-export const readFileTool = {
-    name: 'read_file',
-    description: 'Read a text file. Returns the full content (truncated at 60k chars).',
-    parameters: {
-        type: 'object',
-        properties: { path: { type: 'string', description: 'file path (absolute or relative to cwd)' } },
-        required: ['path'],
-    },
-    async execute(args, ctx) {
-        try {
-            const text = await readFile(safePath(String(args.path), ctx.cwd), 'utf8');
-            return { output: text.length > 60_000 ? text.slice(0, 60_000) + '\n...[truncated]' : text };
-        }
-        catch (err) {
-            return { output: String(err), isError: true };
-        }
-    },
-};
-export const writeFileTool = {
-    name: 'write_file',
-    description: 'Write a text file (creates or overwrites). Use for code, config, docs.',
-    parameters: {
-        type: 'object',
-        properties: {
-            path: { type: 'string', description: 'file path' },
-            content: { type: 'string', description: 'full file content' },
-        },
-        required: ['path', 'content'],
-    },
-    needsApproval: () => true,
-    async execute(args, ctx) {
-        try {
-            const p = safePath(String(args.path), ctx.cwd);
-            await writeFile(p, String(args.content ?? ''), 'utf8');
-            return { output: `wrote ${String(args.content ?? '').length} chars to ${p}` };
-        }
-        catch (err) {
-            return { output: String(err), isError: true };
-        }
-    },
-};
-export const listDirTool = {
-    name: 'list_dir',
-    description: 'List a directory: names with d/- prefix and size.',
-    parameters: {
-        type: 'object',
-        properties: { path: { type: 'string', description: 'directory path (default cwd)' } },
-        required: [],
-    },
-    async execute(args, ctx) {
-        try {
-            const dir = args.path ? safePath(String(args.path), ctx.cwd) : ctx.cwd;
-            const entries = await readdir(dir, { withFileTypes: true });
-            const lines = entries.slice(0, 300).map((e) => `${e.isDirectory() ? 'd' : '-'} ${e.name}`);
-            return { output: `${dir}\n${lines.join('\n') || '(empty)'}` };
-        }
-        catch (err) {
-            return { output: String(err), isError: true };
-        }
-    },
-};
-export const runCommandTool = {
-    name: 'run_command',
-    description: 'Run a shell command (one line, cmd on Windows / sh elsewhere) with a timeout. Prefer focused commands; read output carefully before deciding next steps.',
-    parameters: {
-        type: 'object',
-        properties: {
-            command: { type: 'string', description: 'the command line to run' },
-            timeout_ms: { type: 'number', description: 'timeout in ms (default 60000, max 300000)' },
-        },
-        required: ['command'],
-    },
-    needsApproval: () => true,
-    async execute(args, ctx) {
-        const command = String(args.command ?? '');
-        for (const d of DENY_PATTERNS) {
-            if (d.re.test(command)) {
-                return { output: `Refused: ${d.why}. Ask the user to run it manually if truly intended.`, isError: true };
-            }
-        }
-        const timeout = Math.min(Number(args.timeout_ms ?? 60_000), 300_000);
-        try {
-            const { stdout, stderr } = await execCb(command, {
-                cwd: ctx.cwd,
-                timeout,
-                windowsHide: true,
-                maxBuffer: 8 * 1024 * 1024,
-            });
-            const out = (stdout || '') + (stderr ? `\n[stderr]\n${stderr}` : '');
-            return { output: (out.trim() || '(no output)').slice(0, 60_000) };
-        }
-        catch (err) {
-            const e = err;
-            const parts = [e.stdout, e.stderr, e.killed ? '(timed out)' : null, e.message].filter(Boolean).join('\n');
-            return { output: parts.slice(0, 60_000), isError: true };
-        }
-    },
-};
-export const rememberTool = {
-    name: 'remember',
-    description: 'Persist a note to long-term memory (survives restarts, loaded into future sessions). Use for user preferences, project facts, and hard-won lessons - not transient details.',
-    parameters: {
-        type: 'object',
-        properties: { note: { type: 'string', description: 'the fact/lesson to remember, one line preferred' } },
-        required: ['note'],
-    },
-    async execute(args) {
-        try {
-            const { appendMemory } = await import('@hmh/evolution');
-            await appendMemory(process.env.HMH_HOME ?? join(process.env.USERPROFILE ?? '.', '.hmharness'), String(args.note ?? ''));
-            return { output: 'remembered.' };
-        }
-        catch (err) {
-            return { output: String(err), isError: true };
-        }
-    },
-};
-export const baseTools = [readFileTool, writeFileTool, listDirTool, runCommandTool, rememberTool];