@hyclaw/cli 3.0.1

package/dist/components/CommandPalette.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * CommandPalette — / filterable popup.
+ * Character input is handled by TextInput; this only handles navigation.
+ */
+import { useState, useMemo, useEffect } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { ALL_COMMANDS } from '../commands/index.js';
+export function CommandPalette({ filter, onSelect }) {
+    const [selected, setSelected] = useState(0);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const { stdout } = useStdout();
+    const terminalRows = stdout?.rows || 24;
+    const visible = useMemo(() => {
+        const f = filter.replace(/^\//, '').toLowerCase();
+        if (!f)
+            return ALL_COMMANDS;
+        return ALL_COMMANDS.filter(c => c.cmd.toLowerCase().includes(f) || c.desc.includes(f));
+    }, [filter]);
+    useEffect(() => { setSelected(0); setScrollOffset(0); }, [filter]);
+    const maxShow = Math.max(5, terminalRows - 13);
+    // Keep selected row in view
+    useEffect(() => {
+        setScrollOffset(prev => {
+            if (selected < prev)
+                return selected;
+            if (selected >= prev + maxShow)
+                return selected - maxShow + 1;
+            return prev;
+        });
+    }, [selected, maxShow]);
+    const sliced = visible.slice(scrollOffset, scrollOffset + maxShow);
+    useInput((_input, key) => {
+        if (key.escape) {
+            onSelect(null);
+            return;
+        }
+        if (key.downArrow) {
+            setSelected(prev => Math.min(prev + 1, visible.length - 1));
+            return;
+        }
+        if (key.upArrow) {
+            setSelected(prev => Math.max(prev - 1, 0));
+            return;
+        }
+        if (key.pageDown) {
+            setSelected(prev => Math.min(prev + maxShow, visible.length - 1));
+            return;
+        }
+        if (key.pageUp) {
+            setSelected(prev => Math.max(prev - maxShow, 0));
+            return;
+        }
+        if (key.home) {
+            setSelected(0);
+            return;
+        }
+        if (key.end) {
+            setSelected(visible.length - 1);
+            return;
+        }
+        if (key.return) {
+            if (visible.length > 0 && selected >= 0 && selected < visible.length) {
+                onSelect(visible[selected].cmd);
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", paddingX: 1, width: 52, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: "\u547D\u4EE4\u5217\u8868" }), _jsx(Text, { dimColor: true, children: "  \u2191\u2193\u9009\u62E9 / PgUp/PgDn\u7FFB\u9875 / \u56DE\u8F66\u786E\u8BA4 / Esc\u53D6\u6D88" })] }), sliced.map((cmd, i) => {
+                const idx = scrollOffset + i;
+                return (_jsxs(Box, { paddingLeft: 1, children: [_jsx(Text, { color: idx === selected ? 'cyan' : undefined, bold: idx === selected, children: idx === selected ? '> ' : '  ' }), _jsx(Text, { color: "green", children: cmd.cmd }), _jsxs(Text, { dimColor: true, children: ["  ", cmd.desc] }), _jsxs(Text, { color: cmd.via === 'ws' ? 'yellow' : 'blue', dimColor: idx !== selected, children: ["(", cmd.via === 'ws' ? '后端' : '本地', ")"] })] }, cmd.cmd));
+            }), visible.length > maxShow && (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["  ", scrollOffset + 1, "-", Math.min(scrollOffset + maxShow, visible.length), " / ", visible.length] }) }))] }));
+}

package/dist/components/StatusLine.d.ts

@@ -0,0 +1 @@
+export declare function StatusLine(): import("react/jsx-runtime").JSX.Element;

package/dist/components/StatusLine.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useAppState } from '../hooks/useAppState.js';
+function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${Math.round(n / 1_000)}K`;
+    return String(n);
+}
+export function StatusLine() {
+    const state = useAppState();
+    const { usage, modelName, planMode, autoMode, connected, statusText, messages } = state;
+    const msgCount = messages.length;
+    const pct = Math.min(100, Math.round(usage.usageRatio * 100));
+    const filled = Math.round(pct / 10);
+    const bar = '='.repeat(filled) + '-'.repeat(10 - filled);
+    const model = modelName || (connected ? 'ready' : 'connecting...');
+    const modeLabel = planMode ? ' Plan ' : ' Act ';
+    const modeColor = planMode ? 'cyan' : 'green';
+    const connIcon = connected ? '●' : '○';
+    const connColor = connected ? 'green' : 'red';
+    const isError = statusText.startsWith('Error:');
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", paddingRight: 1, children: [_jsxs(Box, { height: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "jwcode" }), _jsx(Text, { children: "  " }), _jsxs(Text, { backgroundColor: modeColor, color: "black", children: [" ", modeLabel, " "] }), _jsx(Text, { children: "  " }), autoMode && (_jsxs(_Fragment, { children: [_jsx(Text, { backgroundColor: "magenta", color: "black", children: " AUTO " }), _jsx(Text, { children: "  " })] })), _jsxs(Text, { color: connColor, children: [connIcon, " "] }), _jsx(Text, { color: "green", children: model }), _jsx(Text, { children: "  " }), _jsxs(Text, { dimColor: true, children: [msgCount, "msgs"] }), _jsx(Text, { children: "  t: " }), _jsx(Text, { color: "yellow", children: formatTokens(usage.totalTokens) }), _jsx(Text, { children: "  " }), _jsxs(Text, { color: pct > 90 ? 'red' : 'white', children: [bar, " ", pct, "%"] })] }), statusText && statusText !== 'connecting...' && (_jsx(Box, { height: 1, children: _jsx(Text, { color: isError ? 'red' : 'grey', dimColor: !isError, children: statusText.slice(0, 100) }) }))] }));
+}

package/dist/components/TextInput.d.ts

@@ -0,0 +1,10 @@
+export declare function saveToHistory(text: string): void;
+interface Props {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+}
+export declare function TextInput({ value, onChange, onSubmit, placeholder, disabled }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TextInput.js

@@ -0,0 +1,118 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useCallback } from 'react';
+import { Box, Text, useInput } from 'ink';
+// Rough token estimation: English ~4 chars/token, CJK ~1.5 chars/token
+function estimateTokens(text) {
+    let cjk = 0;
+    let other = 0;
+    for (const ch of text) {
+        if (/[一-鿿㐀-䶿豈-﫿　-〿＀-￯]/.test(ch)) {
+            cjk++;
+        }
+        else {
+            other++;
+        }
+    }
+    return Math.ceil(cjk / 1.5 + other / 4);
+}
+const MAX_HISTORY = 30;
+const HISTORY_KEY = 'jwcode-tscli-history';
+function loadHistory() {
+    try {
+        const raw = process.env.JWCODE_HISTORY
+            || (typeof sessionStorage !== 'undefined' ? sessionStorage.getItem(HISTORY_KEY) : null);
+        return raw ? JSON.parse(raw) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function saveHistory(entries) {
+    try {
+        if (typeof sessionStorage !== 'undefined') {
+            sessionStorage.setItem(HISTORY_KEY, JSON.stringify(entries));
+        }
+    }
+    catch { /* ignore */ }
+}
+export function saveToHistory(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return;
+    const history = loadHistory().filter(h => h !== trimmed);
+    history.unshift(trimmed);
+    saveHistory(history.slice(0, MAX_HISTORY));
+}
+export function TextInput({ value, onChange, onSubmit, placeholder, disabled }) {
+    const historyRef = useRef(loadHistory());
+    const histIdxRef = useRef(-1);
+    const draftRef = useRef('');
+    const navigateHistory = useCallback((dir) => {
+        const history = historyRef.current;
+        if (history.length === 0)
+            return null;
+        if (histIdxRef.current === -1) {
+            draftRef.current = value;
+            if (dir === 'up') {
+                histIdxRef.current = 0;
+                return history[0];
+            }
+            return null;
+        }
+        if (dir === 'up') {
+            const next = Math.min(histIdxRef.current + 1, history.length - 1);
+            histIdxRef.current = next;
+            return history[next];
+        }
+        else {
+            const next = histIdxRef.current - 1;
+            if (next < 0) {
+                histIdxRef.current = -1;
+                return draftRef.current;
+            }
+            histIdxRef.current = next;
+            return history[next];
+        }
+    }, [value]);
+    const resetHistory = useCallback(() => {
+        histIdxRef.current = -1;
+        draftRef.current = '';
+    }, []);
+    useInput((input, key) => {
+        if (disabled)
+            return;
+        if (key.return) {
+            onSubmit(value);
+            resetHistory();
+            return;
+        }
+        if (key.upArrow) {
+            const hist = navigateHistory('up');
+            if (hist !== null)
+                onChange(hist);
+            return;
+        }
+        if (key.downArrow) {
+            const hist = navigateHistory('down');
+            if (hist !== null)
+                onChange(hist);
+            return;
+        }
+        // Any manual edit resets history navigation
+        if (histIdxRef.current !== -1 && input) {
+            resetHistory();
+        }
+        if (key.backspace || key.delete) {
+            onChange(value.slice(0, -1));
+            resetHistory();
+        }
+        else if (input && !key.ctrl && !key.meta && !key.tab && !key.escape) {
+            onChange(value + input);
+        }
+    });
+    const display = value || '';
+    const showPlaceholder = !display && placeholder;
+    const tokenEstimate = display ? estimateTokens(display) : 0;
+    const charCount = display.length;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [display ? _jsx(Text, { children: display }) : _jsx(Text, { dimColor: true, children: placeholder }), _jsx(Text, { dimColor: true, children: "\u258A" })] }), charCount > 0 && (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: ["  ", charCount, " \u5B57\u7B26 \u2248 ", tokenEstimate, " tokens"] }), tokenEstimate > 100000 && (_jsx(Text, { color: "red", children: "  \u26A0 \u63A5\u8FD1\u4E0A\u4E0B\u6587\u4E0A\u9650" }))] }))] }));
+}

package/dist/hooks/useAppState.d.ts

@@ -0,0 +1,18 @@
+import { type Store } from '../store.js';
+import type { Message, TokenUsage } from '../protocol.js';
+export interface AppState {
+    messages: Message[];
+    currentMessage: Message | null;
+    usage: TokenUsage;
+    planMode: boolean;
+    autoMode: boolean;
+    planWaiting: boolean;
+    scrollOffset: number;
+    modelName: string;
+    connected: boolean;
+    statusText: string;
+}
+export declare function getStore(): Store<AppState>;
+export declare function useAppState(): AppState;
+export declare function useSetState(): (updater: (prev: AppState) => AppState) => void;
+export declare function updateAppState(updater: (prev: AppState) => AppState): void;

package/dist/hooks/useAppState.js

@@ -0,0 +1,42 @@
+/**
+ * Application state management — React context wrapping the generic store.
+ */
+import { useEffect, useState, useCallback } from 'react';
+import { createStore } from '../store.js';
+const initialState = {
+    messages: [],
+    currentMessage: null,
+    usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, usageRatio: 0 },
+    planMode: false,
+    autoMode: false,
+    planWaiting: false,
+    scrollOffset: 0,
+    modelName: '',
+    connected: false,
+    statusText: 'connecting...',
+};
+let _store = null;
+export function getStore() {
+    if (!_store)
+        _store = createStore(initialState);
+    return _store;
+}
+// Provide context manually since we need to use it outside React
+// We use a module-level store accessed via getStore()
+export function useAppState() {
+    const store = getStore();
+    const [state, setState] = useState(store.getState());
+    useEffect(() => {
+        return store.subscribe(() => setState(store.getState()));
+    }, []);
+    return state;
+}
+export function useSetState() {
+    const store = getStore();
+    return useCallback((updater) => {
+        store.setState(updater);
+    }, []);
+}
+export function updateAppState(updater) {
+    getStore().setState(updater);
+}

package/dist/hooks/useWebSocket.d.ts

@@ -0,0 +1,3 @@
+import { JwCodeClient } from '../client.js';
+export declare function setClient(client: JwCodeClient): void;
+export declare function getClient(): JwCodeClient | null;

package/dist/hooks/useWebSocket.js

@@ -0,0 +1,8 @@
+// Module-level client reference for components that need it outside React context
+let _client = null;
+export function setClient(client) {
+    _client = client;
+}
+export function getClient() {
+    return _client;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@hyclaw/cli",
+  "version": "3.0.1",
+  "description": "JWCode — Java AI Coding Tool TypeScript CLI",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "hyclaw": "./dist/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/download-jre.js"
+  },
+  "dependencies": {
+    "esbuild": "^0.28.0",
+    "ink": "^5.0.0",
+    "marked": "^14.1.0",
+    "react": "^18.3.1",
+    "ws": "^8.18.0"
+  },
+  "files": [
+    "dist/",
+    "backend/",
+    "scripts/download-jre.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/download-jre.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+/**
+ * postinstall — download & extract platform-specific JRE.
+ *
+ * Looks for an existing backend/jre/ first; if found, skips.
+ * Otherwise detects the current platform and downloads a
+ * pre-built JRE archive from a configurable base URL.
+ *
+ * Environment variables:
+ *   JWCODE_JRE_BASE_URL   Base URL for JRE archives (default: see below)
+ *   JWCODE_SKIP_JRE       Set to "1" to skip JRE download entirely
+ *   JWCODE_JRE_VERSION    Java version tag (default: "17")
+ *
+ * Default URL pattern:
+ *   {baseURL}/v{package-version}/jre-{platform}.tar.gz
+ */
+
+import { existsSync, mkdirSync, createWriteStream } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { pipeline } from 'node:stream/promises';
+import { execSync } from 'node:child_process';
+import { platform, arch } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_DIR = join(__dirname, '..');
+const JRE_DIR = join(PACKAGE_DIR, 'backend', 'jre');
+
+// Read version from package.json
+let PACKAGE_VERSION = '0.0.0';
+try {
+  const pkg = JSON.parse(
+    await import('node:fs').then(fs =>
+      fs.promises.readFile(join(PACKAGE_DIR, 'package.json'), 'utf-8')
+    )
+  );
+  PACKAGE_VERSION = pkg.version || PACKAGE_VERSION;
+} catch { /* fallback */ }
+
+const BASE_URL = process.env.JWCODE_JRE_BASE_URL || 'https://github.com/jwcode-project/jwcode/releases/download';
+
+function detectPlatform() {
+  const os = platform();
+  const cpu = arch();
+
+  if (os === 'win32' && cpu === 'x64') return 'win32-x64';
+  if (os === 'darwin' && cpu === 'arm64') return 'darwin-arm64';
+  if (os === 'darwin' && cpu === 'x64') return 'darwin-x64';
+  if (os === 'linux' && cpu === 'x64') return 'linux-x64';
+  if (os === 'linux' && cpu === 'arm64') return 'linux-arm64';
+
+  return null; // unsupported
+}
+
+async function downloadFile(url, destPath) {
+  console.log(`[jre] Downloading: ${url}`);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+  }
+  const total = parseInt(response.headers.get('content-length') || '0', 10);
+  let downloaded = 0;
+  let lastLog = 0;
+
+  // Ensure parent dir exists
+  mkdirSync(dirname(destPath), { recursive: true });
+
+  const writer = createWriteStream(destPath);
+  const reader = response.body;
+
+  reader.on('data', (chunk) => {
+    downloaded += chunk.length;
+    if (total && Date.now() - lastLog > 2000) {
+      const pct = Math.round((downloaded / total) * 100);
+      console.log(`[jre] Progress: ${pct}% (${(downloaded / 1024 / 1024).toFixed(1)} MB)`);
+      lastLog = Date.now();
+    }
+  });
+
+  await pipeline(reader, writer);
+  console.log(`[jre] Downloaded: ${(downloaded / 1024 / 1024).toFixed(1)} MB`);
+}
+
+async function extractArchive(archivePath, targetDir) {
+  mkdirSync(targetDir, { recursive: true });
+
+  const ext = archivePath.endsWith('.zip') ? 'zip' : 'targz';
+
+  console.log(`[jre] Extracting to: ${targetDir}`);
+
+  try {
+    if (ext === 'zip') {
+      // Use system unzip or PowerShell on Windows
+      if (platform() === 'win32') {
+        // Windows: use tar (built-in since Win10) to extract .tar.gz, or PowerShell for .zip
+        execSync(
+          `powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${targetDir}' -Force"`,
+          { stdio: 'pipe', timeout: 120_000 }
+        );
+      } else {
+        execSync(`unzip -o -q "${archivePath}" -d "${targetDir}"`, {
+          stdio: 'pipe', timeout: 120_000
+        });
+      }
+    } else {
+      // tar.gz: use system tar (available on all modern platforms)
+      execSync(
+        `tar -xzf "${archivePath}" -C "${targetDir}"`,
+        { stdio: 'pipe', timeout: 120_000 }
+      );
+    }
+  } catch (err) {
+    // Try Node.js native alternative for .tar.gz
+    if (ext === 'targz') {
+      console.log('[jre] System tar failed, trying Node.js native extraction...');
+      await extractTarGzNative(archivePath, targetDir);
+    } else {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Fallback: extract .tar.gz using Node.js built-in zlib + tar-stream.
+ * This avoids depending on system tar being available.
+ */
+async function extractTarGzNative(archivePath, targetDir) {
+  // We need 'tar' and 'zlib' from npm OR use the built-in zlib + child_process
+  // Since the package depends on 'tar-stream' is not guaranteed, try with
+  // system commands first, then fall back to a pure-Node approach.
+  //
+  // On Windows 10/11, 'tar' is built-in. On Linux/macOS it's always there.
+  // This fallback is a safety net.
+  throw new Error(
+    'Could not extract JRE archive. Ensure system tar is available.\n' +
+    '  Windows 10+:  tar is built-in\n' +
+    '  macOS/Linux:  tar is pre-installed\n' +
+    `  You can also manually extract ${archivePath} to ${targetDir}`
+  );
+}
+
+function findExistingJRE() {
+  if (!existsSync(JRE_DIR)) return false;
+  // Check if it looks like a real JRE (has java binary)
+  const javaBin = platform() === 'win32'
+    ? join(JRE_DIR, 'bin', 'java.exe')
+    : join(JRE_DIR, 'bin', 'java');
+  return existsSync(javaBin);
+}
+
+async function main() {
+  if (process.env.JWCODE_SKIP_JRE === '1') {
+    console.log('[jre] JWCODE_SKIP_JRE=1, skipping JRE download.');
+    return;
+  }
+
+  // Check if JRE already exists
+  if (findExistingJRE()) {
+    console.log('[jre] JRE already exists at backend/jre/, skipping.');
+    return;
+  }
+
+  const plat = detectPlatform();
+  if (!plat) {
+    console.log(`[jre] Unsupported platform: ${platform()} ${arch()}.`);
+    console.log('[jre] System Java 17+ will be required at runtime.');
+    console.log('[jre] To skip this check: JWCODE_SKIP_JRE=1 npm install');
+    return;
+  }
+
+  // Build download URL
+  const tag = `v${PACKAGE_VERSION}`;
+  const archiveName = `jre-${plat}.tar.gz`;
+  const url = `${BASE_URL}/${tag}/${archiveName}`;
+  const destDir = join(PACKAGE_DIR, 'backend');
+  const destPath = join(destDir, archiveName);
+
+  try {
+    console.log(`[jre] Downloading JRE for ${plat}...`);
+    await downloadFile(url, destPath);
+    await extractArchive(destPath, JRE_DIR);
+    console.log('[jre] JRE ready at backend/jre/');
+
+    // Clean up archive
+    try {
+      await import('node:fs').then(fs => fs.promises.unlink(destPath));
+    } catch { /* ignore */ }
+  } catch (err) {
+    console.error(`[jre] Download failed: ${err.message}`);
+    console.log('[jre] System Java 17+ will be required at runtime.');
+    console.log('[jre] You can also manually download JRE from:');
+    console.log(`  ${url}`);
+    console.log(`  and extract it to: backend/jre/`);
+  }
+}
+
+main().catch(err => {
+  console.error('[jre] Unexpected error:', err.message);
+  process.exit(0); // Don't fail the install — fall back to system Java
+});
+