codemini-cli 0.1.1

package/skills/superpowers-lite/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: superpowers-lite
+description: Concise workflow skill tuned for 30B-class models: search first, keep context tight, use sub-agents for narrow tasks, and verify before claiming success.
+version: 0.1.0
+---
+
+Use this skill as the default lightweight operating style for coding work.
+
+Core rules:
+
+1. Search first.
+Use `rg` for repo search before broad file reads. Prefer local context commands and read only the smallest useful slice.
+
+2. Keep context tight.
+Do not carry full conversation history into every step. Summarize, narrow scope, and work from the most recent relevant evidence.
+
+3. Prefer narrow sub-agents.
+When a task can be split cleanly, use sub-agents for bounded subtasks so the main thread keeps global focus. Give each sub-agent:
+- one clear objective
+- a tiny context summary
+- a tiny file evidence packet
+- a concrete expected output
+
+4. Read and write with intent.
+Use `read_file` only when shell output is not enough. Use `write_file` for edits. Avoid unnecessary tool calls and avoid rereading the same file without a reason.
+
+5. Verify before claiming success.
+Run the relevant test, check, or command before saying work is fixed or complete.
+
+Default workflow:
+- Search with `rg`
+- Inspect local context
+- Plan the next smallest step
+- Delegate if the work is independent
+- Edit
+- Verify
+- Summarize briefly
+
+Sub-agent guidance:
+- `planner`: break work into steps, risks, and checks
+- `coder`: implement one bounded change
+- `reviewer`: look for bugs, regressions, and missing verification
+
+If the task is simple, stay lightweight. Do not expand into a large ceremony unless the problem actually needs it.

package/souls/anime.md

@@ -0,0 +1,3 @@
+Respond with a light anime-inspired tone.
+Keep the content useful and technically accurate, but add a playful, upbeat style.
+Do not overdo catchphrases, and do not let the style reduce clarity.

package/souls/default.md

@@ -0,0 +1,3 @@
+Respond in a clear, calm, helpful tone.
+Be concise, friendly, and practical.
+Avoid roleplay, slang overload, or exaggerated personality.

package/souls/playful.md

@@ -0,0 +1,3 @@
+Respond with a witty and lively tone.
+Keep the answer readable and practical first, but allow a bit more personality and humor.
+Do not let humor obscure instructions or technical accuracy.

package/souls/professional.md

@@ -0,0 +1,3 @@
+Respond in a polished, professional tone.
+Keep phrasing precise, confident, and concise.
+Prefer structured explanations over playful expression.

package/src/cli.js

@@ -0,0 +1,62 @@
+import { handleChat } from './commands/chat.js';
+import { handleRun } from './commands/run.js';
+import { handleConfig } from './commands/config.js';
+import { handleDoctor } from './commands/doctor.js';
+import { handleSkill } from './commands/skill.js';
+
+const VERSION = '0.1.0';
+
+function printHelp() {
+  console.log(`codemini ${VERSION}
+Usage:
+  codemini [prompt] [--plain]
+  codemini chat [prompt] [--plain]
+  codemini run <task> [--max-steps N]
+  codemini config set|get|list <key> [value]
+  codemini doctor
+  codemini skill list|install|enable|disable|inspect|reindex
+  codemini --version
+  codemini --help`);
+}
+
+export async function runCli(args) {
+  const [command, ...rest] = args;
+  const knownCommands = new Set(['chat', 'run', 'config', 'doctor', 'skill']);
+
+  if (!command || command === '--help' || command === '-h') {
+    if (!command) {
+      await handleChat([]);
+      return;
+    }
+    printHelp();
+    return;
+  }
+
+  if (command === '--version' || command === '-v' || command === 'version') {
+    console.log(VERSION);
+    return;
+  }
+
+  if (!knownCommands.has(command)) {
+    await handleChat(args);
+    return;
+  }
+
+  switch (command) {
+    case 'chat':
+      await handleChat(rest);
+      return;
+    case 'run':
+      await handleRun(rest);
+      return;
+    case 'config':
+      await handleConfig(rest);
+      return;
+    case 'doctor':
+      await handleDoctor();
+      return;
+    case 'skill':
+      await handleSkill(rest);
+      return;
+  }
+}

package/src/commands/chat.js

@@ -0,0 +1,106 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { loadConfig } from '../core/config-store.js';
+import { createChatRuntime } from '../core/chat-runtime.js';
+import { buildDefaultSystemPrompt } from '../core/default-system-prompt.js';
+import { resolveSession } from '../core/session-store.js';
+import pkg from '../../package.json' with { type: 'json' };
+
+function parseChatArgs(args) {
+  const parsed = {
+    prompt: '',
+    sessionId: undefined,
+    model: undefined,
+    system: undefined,
+    plain: false
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--session') {
+      parsed.sessionId = args[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === '--model') {
+      parsed.model = args[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === '--system') {
+      parsed.system = args[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === '--plain') {
+      parsed.plain = true;
+      continue;
+    }
+    parsed.prompt += `${parsed.prompt ? ' ' : ''}${arg}`;
+  }
+
+  return parsed;
+}
+
+async function runPlainLoop(runtime) {
+  console.log('CodeMini CLI plain mode. Use /help and /exit.');
+  const rl = readline.createInterface({ input, output });
+  try {
+    while (true) {
+      let line;
+      try {
+        line = await rl.question('codemini> ');
+      } catch {
+        break;
+      }
+      const result = await runtime.submit(line);
+      if (result.type === 'exit') break;
+      if (result.type === 'noop') continue;
+      if (result.text) console.log(result.text);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+export async function handleChat(args) {
+  const parsed = parseChatArgs(args);
+  const config = await loadConfig();
+  const session = await resolveSession(parsed.sessionId);
+  const systemPrompt =
+    parsed.system ||
+    buildDefaultSystemPrompt(config);
+
+  const runtime = await createChatRuntime({
+    session,
+    config,
+    model: parsed.model,
+    systemPrompt
+  });
+
+  if (parsed.prompt) {
+    const result = await runtime.submit(parsed.prompt);
+    if (result.text) console.log(result.text);
+    return;
+  }
+
+  if (parsed.plain || !process.stdout.isTTY) {
+    await runPlainLoop(runtime);
+    return;
+  }
+
+  const React = (await import('react')).default;
+  const { render } = await import('ink');
+  const { ChatApp } = await import('../tui/chat-app.js');
+  const instance = render(
+    React.createElement(ChatApp, {
+      runtime,
+      sessionId: session.id,
+      model: parsed.model || config.model.name,
+      language: config.ui?.language || 'zh',
+      shellName: config.shell?.default || 'powershell',
+      version: pkg.version
+    })
+  );
+  await instance.waitUntilExit();
+}

package/src/commands/config.js

@@ -0,0 +1,61 @@
+import { getConfigValue, loadConfig, resetConfig, setConfigValue } from '../core/config-store.js';
+
+function usage() {
+  console.log(`Usage:
+  codemini config set <key> <value>
+  codemini config get <key>
+  codemini config list
+  codemini config reset`);
+}
+
+export async function handleConfig(args) {
+  const [sub, ...rest] = args;
+
+  if (!sub) {
+    usage();
+    return;
+  }
+
+  if (sub === 'set') {
+    const [key, ...valueParts] = rest;
+    if (!key || valueParts.length === 0) {
+      throw new Error('config set requires <key> <value>');
+    }
+    const value = valueParts.join(' ');
+    await setConfigValue(key, value);
+    console.log(`Set ${key}=${value}`);
+    return;
+  }
+
+  if (sub === 'get') {
+    const [key] = rest;
+    if (!key) {
+      throw new Error('config get requires <key>');
+    }
+    const value = await getConfigValue(key);
+    if (value === undefined) {
+      console.log('undefined');
+      return;
+    }
+    if (typeof value === 'object') {
+      console.log(JSON.stringify(value, null, 2));
+      return;
+    }
+    console.log(String(value));
+    return;
+  }
+
+  if (sub === 'list') {
+    const config = await loadConfig();
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+
+  if (sub === 'reset') {
+    await resetConfig();
+    console.log('Config reset complete');
+    return;
+  }
+
+  usage();
+}

package/src/commands/doctor.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getConfigFilePath, getSessionsDir, getSkillsDir } from '../core/paths.js';
+import { loadConfig } from '../core/config-store.js';
+
+async function checkPathWritable(targetPath) {
+  try {
+    await fs.mkdir(targetPath, { recursive: true });
+    const tmp = `${targetPath}/.doctor-write-test`;
+    await fs.writeFile(tmp, 'ok', 'utf8');
+    await fs.unlink(tmp);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkGateway(config) {
+  if (!config.gateway.base_url || !config.gateway.api_key) {
+    return { ok: false, reason: 'gateway.base_url or gateway.api_key missing' };
+  }
+  const url = `${config.gateway.base_url.replace(/\/$/, '')}/models`;
+  try {
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${config.gateway.api_key}` }
+    });
+    if (!res.ok) {
+      return { ok: false, reason: `HTTP ${res.status}` };
+    }
+    return { ok: true, reason: 'reachable' };
+  } catch (err) {
+    return { ok: false, reason: err.message };
+  }
+}
+
+export async function handleDoctor() {
+  const config = await loadConfig();
+  const checks = [];
+
+  checks.push({
+    name: 'Node.js version',
+    ok: Number(process.versions.node.split('.')[0]) >= 20,
+    detail: process.versions.node
+  });
+
+  checks.push({
+    name: 'Platform',
+    ok: process.platform === 'win32',
+    detail: process.platform === 'win32' ? 'win32' : `non-win32 (${process.platform})`
+  });
+
+  checks.push({
+    name: 'Config file writable',
+    ok: await checkPathWritable(path.dirname(getConfigFilePath())),
+    detail: getConfigFilePath()
+  });
+
+  checks.push({
+    name: 'Sessions dir writable',
+    ok: await checkPathWritable(getSessionsDir()),
+    detail: getSessionsDir()
+  });
+
+  checks.push({
+    name: 'Skills dir writable',
+    ok: await checkPathWritable(getSkillsDir()),
+    detail: getSkillsDir()
+  });
+
+  const gateway = await checkGateway(config);
+  checks.push({
+    name: 'Gateway connectivity',
+    ok: gateway.ok,
+    detail: gateway.reason
+  });
+
+  for (const check of checks) {
+    const mark = check.ok ? 'OK' : 'FAIL';
+    console.log(`[${mark}] ${check.name}: ${check.detail}`);
+  }
+
+  const failed = checks.filter((c) => !c.ok).length;
+  if (failed > 0) {
+    process.exitCode = 1;
+  }
+}

package/src/commands/run.js

@@ -0,0 +1,64 @@
+import { loadConfig } from '../core/config-store.js';
+import { buildDefaultSystemPrompt } from '../core/default-system-prompt.js';
+import { runAgentLoop } from '../core/agent-loop.js';
+import { createChatCompletion } from '../core/provider/openai-compatible.js';
+import { buildSystemPromptWithSoul } from '../core/soul.js';
+import { getBuiltinTools } from '../core/tools.js';
+
+function parseRunArgs(args) {
+  const parsed = {
+    task: '',
+    model: undefined,
+    maxSteps: 8
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--model') {
+      parsed.model = args[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === '--max-steps') {
+      parsed.maxSteps = Number(args[i + 1] || 8);
+      i += 1;
+      continue;
+    }
+    parsed.task += `${parsed.task ? ' ' : ''}${arg}`;
+  }
+  return parsed;
+}
+
+export async function handleRun(args) {
+  const parsed = parseRunArgs(args);
+  if (!parsed.task) {
+    throw new Error('run requires <task>');
+  }
+
+  const config = await loadConfig();
+  const { definitions, handlers } = getBuiltinTools({
+    workspaceRoot: process.cwd(),
+    config
+  });
+  const systemPrompt = await buildSystemPromptWithSoul(buildDefaultSystemPrompt(config), config);
+
+  const result = await runAgentLoop({
+    systemPrompt,
+    userPrompt: parsed.task,
+    model: parsed.model || config.model.name,
+    toolDefinitions: definitions,
+    toolHandlers: handlers,
+    maxSteps: parsed.maxSteps,
+    requestCompletion: async ({ messages, tools, model }) =>
+      createChatCompletion({
+        baseUrl: config.gateway.base_url,
+        apiKey: config.gateway.api_key,
+        model,
+        messages,
+        tools,
+        timeoutMs: config.gateway.timeout_ms || 90000,
+        maxRetries: config.gateway.max_retries ?? 2
+      })
+  });
+
+  console.log(result.text);
+}