pelulu-cli 1.0.0

package/README.md

@@ -0,0 +1,273 @@
+# Pelulu CLI 🐾
+
+> A CLI coding agent powered by [XiaoZhi](https://xiaozhi.me) — yes, the tiny Chinese AI model that lives in ESP32 chips. We gave it 15 tools and a terminal. What could go wrong?
+
+```
+╭────────────────────────────────────────────────╮
+│                   🐾 Pelulu CLI                   │
+├────────────────────────────────────────────────┤
+│  📁 my-project                                 │
+│  🔧 15 tools · 67 actions · 15 MCP slots used  │
+│  🟢 Connected to XiaoZhi                       │
+╰────────────────────────────────────────────────╯
+```
+
+## What is this?
+
+Pelulu CLI is a terminal-based AI coding agent that connects to XiaoZhi (a small Chinese LLM designed for IoT devices) via MQTT and MCP protocol. It gives the AI access to 15 consolidated tools so it can read your files, run commands, manage git, and generally pretend to be a competent developer.
+
+**Why XiaoZhi?** Because sometimes you don't need GPT-4 to write your `hello.txt`. Sometimes you need a model that runs on a $3 chip and responds in Mandarin. We're not here to judge.
+
+## Features
+
+- **15 Consolidated Tools** — 67 actions packed into 15 MCP slots (because XiaoZhi has a 32-tool limit and we're not wasteful)
+- **Rich TUI** — Box drawing, colors, emoji. Your terminal will look like a hacker movie from 2003
+- **Auto-detect Projects** — `cd my-project && pelulu` and it figures out the rest
+- **Safety Sandbox** — Won't let the AI `rm -rf /` (we tested... extensively)
+- **Destructive Op Confirmation** — Asks before deleting your life's work
+- **Intent Parser** — Type `read index.js` instead of `/call file read {"path":"index.js"}` like a civilized person
+- **Session Persistence** — Remembers your device ID so you don't have to re-activate every time
+- **Plugin System** — Add your own tools (if 67 actions aren't enough for you)
+- **Auto-reconnect** — MQTT disconnects happen. We handle them. Mostly.
+
+
+## Quick Start
+
+```bash
+# Install globally from npm
+npm install -g pelulu-cli
+
+# Go to any project and run
+cd ~/my-awesome-project
+pelulu
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/venenapro/Pelulu-CLI.git
+cd Pelulu-CLI
+npm install
+npm link
+pelulu
+```
+
+First run: you'll get an activation code. Go to [xiaozhi.me](https://xiaozhi.me), enter it, and boom — your tiny AI overlord is ready.
+
+## Tools
+
+| Tool | Actions | What it does |
+|------|---------|-------------|
+| `file` | read, write, edit, list, delete, mkdir, copy, move, exists | File operations (9 actions, 1 MCP slot — efficiency™) |
+| `shell` | exec, bg, ps, kill | Run commands (with safety rails) |
+| `git` | init, clone, status, diff, log, add, commit, push, pull, branch | Full git workflow |
+| `search` | grep, find, web | Search files and the internet |
+| `project` | init, build, test, lint, deps, info | Auto-detect Node/Python/Rust/Go/Java |
+| `process` | list, info, kill, top | Process management |
+| `network` | fetch, download, ping | HTTP requests |
+| `env` | get, set, list | Environment variables |
+| `ai` | explain, analyze, detectLanguage, summarize, diff | Code analysis |
+| `snippet` | save, load, list, delete | Code snippet library |
+| `template` | list, create, info | Project scaffolding |
+| `history` | list, clear, stats | Tool call history |
+| `config` | get, set, list, reset | Runtime configuration |
+| `diff` | compare, stats, patch | File comparison |
+| `watch` | start, stop, status | File change monitoring |
+
+## Commands
+
+```
+pelulu                    # Start interactive REPL in current directory
+pelulu --list-tools       # Show all available tools
+pelulu --debug            # Enable debug logging
+pelulu --wizard           # Re-run setup wizard
+```
+
+### In-App Commands
+
+```
+/tools                  # Show MCP tools
+/help <tool>            # Tool examples (e.g. /help file)
+/status                 # Connection & session info
+/stats                  # Usage statistics
+/workspace              # Project info
+/files                  # File changes this session
+/call <tool>            # Call tool directly
+/doctor                 # Health check
+/model                  # Model info
+/clear                  # Clear screen
+/quit                   # Exit
+```
+
+### Shortcuts (Natural Language)
+
+```
+read index.js           → file read
+run npm test            → shell exec
+git status              → git status
+build                   → project build
+search TODO             → search grep
+```
+
+## Fun Facts 🎉
+
+- **XiaoZhi's main job** is being a voice assistant for ESP32 microcontrollers. We basically gave a thermostat the ability to `git push --force`
+- **The 32-tool limit** exists because XiaoZhi was designed to control smart home devices, not write your React app. We consolidated 67 actions into 15 tools just to fit
+- **It responds in Mandarin** sometimes. We consider this a feature, not a bug. 非常好！
+- **The MQTT protocol** was chosen because that's what IoT devices use. Your coding agent runs on the same protocol as your smart fridge
+- **XiaoZhi costs approximately $0** to run. Your coding agent is cheaper than a cup of coffee. The quality is... also about that
+- **We tested `rm -rf /`** protection extensively. The AI suggested it exactly once. It was blocked. The AI seemed disappointed
+- **The model runs on a Tenclass server** somewhere in China. Your code is being reviewed by an AI that was trained to turn on lights and play music
+- **15 MCP slots used** out of 32. That's 17 slots free for when someone inevitably asks us to add a "make coffee" tool
+
+## Architecture
+
+```
+┌──────────────┐     MQTT      ┌──────────────┐     MCP      ┌──────────────┐
+│  XiaoZhi AI  │ ←──────────→ │   Pelulu CLI   │ ←──────────→ │  15 Tools    │
+│  (tiny LLM)  │              │   (router)   │              │  (67 actions)│
+└──────────────┘              └──────────────┘              └──────────────┘
+                                    ↕
+                              ┌──────────────┐
+                              │   Rich TUI   │
+                              └──────────────┘
+```
+
+```
+src/
+├── index.js                ← Entry point
+├── repl.js                 ← CLI interface
+├── repl-commands.js        ← Command handlers
+├── core/
+│   ├── config.js           ← Config loader
+│   ├── event-bus.js        ← Pub/sub
+│   ├── logger.js           ← Logging
+│   ├── tool-registry.js    ← Tool registry
+│   ├── sandbox.js          ← Safety layer
+│   ├── session.js          ← Session state
+│   ├── system-prompt.js    ← Prompt builder
+│   ├── context.js          ← Context injection
+│   ├── confirm.js          ← Confirmation system
+│   ├── diff.js             ← Diff display
+│   ├── spinner.js          ← Progress indicators
+│   ├── workspace.js        ← Workspace detection
+│   ├── stats.js            ← Usage analytics
+│   ├── conversation.js     ← Conv export/import
+│   ├── wizard.js           ← Config wizard
+│   ├── formatter.js        ← Rich output formatting
+│   ├── tool-help.js        ← Tool examples
+│   ├── intent.js           ← Natural language parser
+│   ├── file-tracker.js     ← File change tracking
+│   ├── auto-format.js      ← Code auto-format
+│   ├── error-handler.js    ← Smart errors
+│   ├── thinking.js         ← AI state indicator
+│   ├── model-info.js       ← Model info
+│   ├── keybindings.js      ← Keyboard shortcuts
+│   ├── completion.js       ← Command completion
+│   └── retry.js            ← Retry logic
+├── mcp/
+│   ├── mqtt-client.js      ← MQTT connection
+│   ├── mcp-handler.js      ← MCP protocol
+│   ├── activation.js       ← Device activation
+│   ├── message-sender.js   ← Message queue
+│   └── wss-endpoint.js     ← WSS endpoint
+├── tools/
+│   ├── file.js, shell.js, git.js, search.js
+│   ├── project.js, process.js, network.js
+│   ├── env.js, ai.js, snippet.js
+│   ├── template.js, history.js, config.js
+│   ├── diff.js, watch.js
+├── plugins/
+│   └── manager.js          ← Plugin loader
+└── tui/
+    ├── renderer.js         ← Rich TUI (chalk)
+    └── status-bar.js       ← Status bar
+```
+
+## Extending
+
+### Add a New Tool
+
+Create `src/tools/mytool.js`:
+
+```js
+const ACTIONS = {
+  greet: {
+    required: ['name'],
+    handler: async ({ name }) => ({ message: `Hello, ${name}!` }),
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'mytool',
+  description: 'My custom tool',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      name: { type: 'string' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown: ${action}`);
+    for (const f of a.required) {
+      if (params[f] === undefined) throw new Error(`Missing: ${f}`);
+    }
+    return a.handler(params);
+  },
+};
+```
+
+Auto-loaded on next restart. Uses 1 MCP slot.
+
+### Add a Plugin
+
+Create `src/plugins/myplugin.js`:
+
+```js
+export default {
+  name: 'myplugin',
+  version: '1.0.0',
+  description: 'My plugin',
+  async init({ bus, config }) { },
+  tools: [{ name: '...', description: '...', inputSchema: {...}, handler: async () => {} }],
+  async shutdown() { },
+};
+```
+
+## Known Issues
+
+- XiaoZhi sometimes responds in Mandarin. This is a feature.
+- Complex requests (8+ files) may timeout. The model needs to think. It's doing its best.
+- The AI occasionally suggests `rm -rf /` as a solution. We block it. The AI learns nothing.
+- MQTT connections can be unstable. We reconnect. It's fine. Everything is fine.
+- The model is small. Like, really small. It runs on chips that cost less than a candy bar.
+
+## Why "Nexa"?
+
+Because it sounds cool and vaguely futuristic. Also "xiaozhi-cli" was already taken (by us, in a previous life). We wanted something that says "this is a serious developer tool" while secretly knowing it's powered by an AI that was trained to control smart light bulbs.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b feature/amazing`)
+3. Commit your changes (`git commit -m 'feat: add amazing'`)
+4. Push to the branch (`git push origin feature/amazing`)
+5. Open a Pull Request
+
+## License
+
+MIT — do whatever you want with it. If you make money using an AI that was designed for ESP32 chips, you deserve it.
+
+---
+
+<p align="center">
+  Built with ❤️ and questionable decisions<br>
+  Powered by <a href="https://xiaozhi.me">XiaoZhi</a> — the little AI that could<br>
+  <sub>It's not stupid, it's compact</sub>
+</p>

package/config.example.json

@@ -0,0 +1,24 @@
+{
+  "agent": {
+    "name": "Nexa CLI",
+    "version": "1.0.0",
+    "workspace": "~/Nexa-CLI"
+  },
+  "mqtt": {
+    "ota_url": "https://api.tenclass.net/xiaozhi/ota/",
+    "keepalive": 240,
+    "reconnect_period": 5000,
+    "connect_timeout": 10000
+  },
+  "mcp": {
+    "endpoint_url": ""
+  },
+  "tools": {
+    "shell_timeout": 30000,
+    "max_output": 10000
+  },
+  "plugins": {
+    "enabled": [],
+    "disabled": []
+  }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "pelulu-cli",
+  "version": "1.0.0",
+  "description": "CLI coding agent powered by XiaoZhi AI — a tiny Chinese LLM that lives in ESP32 chips",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "pelulu": "src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "start:text": "node src/index.js --text",
+    "start:debug": "node src/index.js --debug",
+    "tools": "node src/index.js --list-tools",
+    "test": "node src/index.js --test"
+  },
+  "keywords": [
+    "cli",
+    "coding-agent",
+    "ai",
+    "xiaozhi",
+    "mcp",
+    "mqtt",
+    "terminal",
+    "developer-tools"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chaerulchas/Pelulu-CLI.git"
+  },
+  "bugs": {
+    "url": "https://github.com/chaerulchas/Pelulu-CLI/issues"
+  },
+  "homepage": "https://github.com/chaerulchas/Pelulu-CLI#readme",
+  "author": "chaerulchas",
+  "license": "MIT",
+  "dependencies": {
+    "mqtt": "^5.3.0",
+    "chalk": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/core/auto-format.js

@@ -0,0 +1,47 @@
+/**
+ * AutoFormat — format code after edits
+ * Detects project type and runs appropriate formatter
+ */
+import { exec } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getConfig } from './config.js';
+import { log, debug } from './logger.js';
+
+const FORMATTERS = {
+  node: { cmd: 'npx prettier --write', ext: ['js', 'jsx', 'ts', 'tsx', 'json', 'md'] },
+  python: { cmd: 'python -m black', ext: ['py'] },
+  rust: { cmd: 'rustfmt', ext: ['rs'] },
+  go: { cmd: 'gofmt -w', ext: ['go'] },
+};
+
+async function detectType(cwd) {
+  if (existsSync(join(cwd, 'package.json'))) return 'node';
+  if (existsSync(join(cwd, 'pyproject.toml')) || existsSync(join(cwd, 'requirements.txt'))) return 'python';
+  if (existsSync(join(cwd, 'Cargo.toml'))) return 'rust';
+  if (existsSync(join(cwd, 'go.mod'))) return 'go';
+  return null;
+}
+
+export async function autoFormat(filePath) {
+  const cfg = getConfig();
+  if (!cfg.tools?.auto_format) return; // disabled by default
+
+  const cwd = cfg.agent?.workspace || process.cwd();
+  const type = await detectType(cwd);
+  if (!type) return;
+
+  const formatter = FORMATTERS[type];
+  if (!formatter) return;
+
+  const ext = filePath.split('.').pop()?.toLowerCase();
+  if (!formatter.ext.includes(ext)) return;
+
+  return new Promise((resolve) => {
+    exec(`${formatter.cmd} "${filePath}"`, { cwd, timeout: 10000 }, (err, stdout, stderr) => {
+      if (err) debug(`Auto-format failed: ${err.message}`);
+      else log('file', `🎨 Formatted: ${filePath}`);
+      resolve(!err);
+    });
+  });
+}

package/src/core/completion.js

@@ -0,0 +1,65 @@
+/**
+ * Completion — command completion hints for REPL
+ */
+const COMMANDS = [
+  '/tools', '/help', '/status', '/stats', '/workspace', '/files',
+  '/call', '/conv', '/history', '/doctor', '/model', '/clear', '/quit',
+];
+
+const TOOL_NAMES = [
+  'file', 'shell', 'git', 'search', 'project', 'process',
+  'network', 'env', 'ai', 'snippet', 'template', 'history',
+  'config', 'diff', 'watch',
+];
+
+const ACTIONS = {
+  file: ['read', 'write', 'edit', 'list', 'delete', 'mkdir', 'copy', 'move', 'exists'],
+  shell: ['exec', 'bg', 'ps', 'kill'],
+  git: ['init', 'clone', 'status', 'diff', 'log', 'add', 'commit', 'push', 'pull', 'branch'],
+  search: ['grep', 'find', 'web'],
+  project: ['init', 'build', 'test', 'lint', 'deps', 'info'],
+  process: ['list', 'info', 'kill', 'top'],
+  network: ['fetch', 'download', 'ping'],
+  env: ['get', 'set', 'list'],
+  ai: ['explain', 'analyze', 'detectLanguage', 'summarize', 'diff'],
+  snippet: ['save', 'load', 'list', 'delete'],
+  template: ['list', 'create', 'info'],
+  history: ['list', 'clear', 'stats'],
+  config: ['get', 'set', 'list', 'reset'],
+  diff: ['compare', 'stats', 'patch'],
+  watch: ['start', 'stop', 'status'],
+};
+
+export function getCompletions(input) {
+  const parts = input.trim().split(/\s+/);
+
+  // Command completion
+  if (parts.length === 1 && parts[0].startsWith('/')) {
+    return COMMANDS.filter(c => c.startsWith(parts[0]));
+  }
+
+  // Tool name completion after /call
+  if (parts[0] === '/call' && parts.length === 2) {
+    return TOOL_NAMES.filter(t => t.startsWith(parts[1]));
+  }
+
+  // Action completion after /call <tool>
+  if (parts[0] === '/call' && parts.length === 3) {
+    const tool = parts[1];
+    const actions = ACTIONS[tool];
+    if (actions) return actions.filter(a => a.startsWith(parts[2]));
+  }
+
+  // Intent completion
+  if (parts.length === 1) {
+    const intents = ['read', 'write', 'edit', 'run', 'git', 'build', 'test', 'search', 'ls', 'mkdir', 'kill', 'fetch', 'ping', 'analyze'];
+    return intents.filter(i => i.startsWith(parts[0]));
+  }
+
+  return [];
+}
+
+export function formatCompletions(completions) {
+  if (!completions.length) return '';
+  return completions.map(c => `  ${c}`).join('\n');
+}

package/src/core/config.js

@@ -0,0 +1,68 @@
+/**
+ * Config — load, merge, save configuration
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+const CONFIG_FILE = 'config.json';
+const HOME = homedir();
+
+function expand(p) {
+  return p?.replace(/^~(?=$|[/\\])/g, HOME) ?? p;
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+let _config = null;
+
+export async function loadConfig(root) {
+  const path = join(root, CONFIG_FILE);
+  const defaults = {
+    agent: { name: 'Pelulu CLI', version: '1.0.0', workspace: '~/Pelulu-CLI' },
+    mqtt: { ota_url: 'https://api.tenclass.net/xiaozhi/ota/', keepalive: 240 },
+    mcp: { endpoint_url: '' },
+    tools: { shell_timeout: 30000, max_output: 10000 },
+    plugins: { enabled: [], disabled: [] },
+  };
+
+  if (existsSync(path)) {
+    try {
+      const raw = await readFile(path, 'utf-8');
+      _config = deepMerge(defaults, JSON.parse(raw));
+    } catch { _config = defaults; }
+  } else {
+    _config = defaults;
+    await saveConfig(root, _config);
+  }
+
+  _config._root = root;
+  _config._path = path;
+  _config.agent.workspace = expand(_config.agent.workspace);
+  return _config;
+}
+
+export function getConfig() {
+  if (!_config) throw new Error('Config not loaded');
+  return _config;
+}
+
+export async function saveConfig(root, config) {
+  const path = join(root, CONFIG_FILE);
+  await mkdir(dirname(path), { recursive: true });
+  const { _root, _path, ...clean } = config;
+  await writeFile(path, JSON.stringify(clean, null, 2), 'utf-8');
+}
+
+export { expand };

package/src/core/confirm.js

@@ -0,0 +1,51 @@
+/**
+ * Confirm — ask before destructive operations
+ * Pattern: Claude Code asks before rm, force push, overwrite, etc.
+ */
+import { createInterface } from 'readline';
+import { COLORS } from './logger.js';
+
+const DESTRUCTIVE_PATTERNS = [
+  { pattern: /delete|remove|rm/i, level: 'warn', msg: 'This will delete files' },
+  { pattern: /force.*push|push.*force/i, level: 'danger', msg: 'Force push will overwrite remote' },
+  { pattern: /reset.*--hard/i, level: 'danger', msg: 'Hard reset will lose changes' },
+  { pattern: /checkout.*--force/i, level: 'warn', msg: 'Force checkout will discard changes' },
+  { pattern: /drop.*table|truncate/i, level: 'danger', msg: 'Database destructive operation' },
+  { pattern: /chmod.*777/i, level: 'warn', msg: 'Insecure permissions' },
+];
+
+export function isDestructive(toolName, args) {
+  const str = JSON.stringify(args);
+  for (const { pattern, level, msg } of DESTRUCTIVE_PATTERNS) {
+    if (pattern.test(str)) return { destructive: true, level, msg };
+  }
+  if (toolName === 'file' && args.action === 'delete') return { destructive: true, level: 'warn', msg: 'Delete file' };
+  if (toolName === 'shell' && /rm\s/.test(args.command)) return { destructive: true, level: 'warn', msg: 'Remove files' };
+  return { destructive: false };
+}
+
+export async function askConfirmation(toolName, args, check) {
+  if (!check.destructive) return true;
+
+  const color = check.level === 'danger' ? COLORS.red : COLORS.yellow;
+  const icon = check.level === 'danger' ? '🚨' : '⚠️';
+
+  console.log(`\n${color}${icon} ${check.msg}${COLORS.reset}`);
+  console.log(`${COLORS.dim}  Tool: ${toolName}${COLORS.reset}`);
+  console.log(`${COLORS.dim}  Args: ${JSON.stringify(args).slice(0, 100)}${COLORS.reset}`);
+
+  if (!process.stdin.isTTY) {
+    console.log(`${COLORS.yellow}  Auto-approved (non-interactive)${COLORS.reset}\n`);
+    return true;
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${color}  Continue? (y/N): ${COLORS.reset}`, (answer) => {
+      rl.close();
+      const ok = answer.trim().toLowerCase() === 'y';
+      if (!ok) console.log(`${COLORS.red}  ❌ Cancelled${COLORS.reset}\n`);
+      resolve(ok);
+    });
+  });
+}

package/src/core/context.js

@@ -0,0 +1,69 @@
+/**
+ * Context — inject workspace context into prompts
+ * Like Claude Code: auto-detect project, git status, recent files
+ */
+import { exec } from 'child_process';
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getConfig } from './config.js';
+
+function run(cmd, cwd, timeout = 5000) {
+  return new Promise((resolve) => {
+    exec(cmd, { cwd, timeout, maxBuffer: 256 * 1024 }, (_, stdout) => resolve(stdout?.trim() || ''));
+  });
+}
+
+export async function buildContext() {
+  const cfg = getConfig();
+  const cwd = cfg.agent?.workspace || process.cwd();
+  const lines = [];
+
+  // Git context
+  if (existsSync(join(cwd, '.git'))) {
+    const branch = await run('git rev-parse --abbrev-ref HEAD', cwd);
+    const status = await run('git status --porcelain', cwd);
+    const lastCommit = await run('git log --oneline -1', cwd);
+    lines.push(`Git: branch=${branch}, ${status.split('\n').filter(Boolean).length} changes`);
+    if (lastCommit) lines.push(`Last commit: ${lastCommit}`);
+  }
+
+  // Project context
+  const type = await detectType(cwd);
+  lines.push(`Project: ${type}`);
+
+  if (type === 'node') {
+    try {
+      const pkg = JSON.parse(await readFile(join(cwd, 'package.json'), 'utf-8'));
+      lines.push(`Package: ${pkg.name}@${pkg.version}`);
+      if (pkg.scripts) lines.push(`Scripts: ${Object.keys(pkg.scripts).join(', ')}`);
+    } catch {}
+  }
+
+  // Node/npm versions
+  const nodeVer = await run('node --version', cwd);
+  const npmVer = await run('npm --version', cwd);
+  lines.push(`Runtime: node=${nodeVer}, npm=${npmVer}`);
+
+  return lines.join('\n');
+}
+
+async function detectType(cwd) {
+  const checks = [
+    ['package.json', 'node'], ['requirements.txt', 'python'], ['pyproject.toml', 'python'],
+    ['Cargo.toml', 'rust'], ['go.mod', 'go'], ['CMakeLists.txt', 'cmake'],
+    ['Makefile', 'make'], ['pom.xml', 'java'], ['build.gradle', 'gradle'],
+  ];
+  for (const [file, type] of checks) {
+    if (existsSync(join(cwd, file))) return type;
+  }
+  return 'unknown';
+}
+
+export async function getWorkspaceSummary() {
+  const cfg = getConfig();
+  const cwd = cfg.agent?.workspace || process.cwd();
+  const type = await detectType(cwd);
+  const git = existsSync(join(cwd, '.git'));
+  return { path: cwd, type, hasGit: git };
+}