codemini-cli 0.1.1

package/src/commands/skill.js

@@ -0,0 +1,264 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import { copyRecursive } from '../core/fs-utils.js';
+import { getSkillsDir } from '../core/paths.js';
+import {
+  computeFileSha256,
+  readSkillRegistry,
+  upsertSkillRegistryEntry,
+  writeSkillRegistry
+} from '../core/skill-registry.js';
+
+async function listSkillEntries() {
+  const registry = await readSkillRegistry();
+  const byName = new Map((registry.skills || []).map((s) => [s.name, s]));
+  await fs.mkdir(getSkillsDir(), { recursive: true });
+  const entries = await fs.readdir(getSkillsDir(), { withFileTypes: true });
+  const names = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  return names.map((name) => byName.get(name) || { name, version: 'unknown', enabled: true });
+}
+
+async function readSkillMeta(name) {
+  const dir = path.join(getSkillsDir(), name);
+  const manifestPath = path.join(dir, 'manifest.json');
+  let manifest = null;
+  try {
+    manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+  } catch {
+    manifest = null;
+  }
+  const entryFile = manifest?.entry || 'SKILL.md';
+  const skillPath = path.join(dir, entryFile);
+  try {
+    const content = await fs.readFile(skillPath, 'utf8');
+    const firstLines = content.split('\n').slice(0, 20).join('\n');
+    return { exists: true, path: skillPath, preview: firstLines, manifest };
+  } catch {
+    return { exists: false, path: skillPath, preview: '', manifest };
+  }
+}
+
+async function runTarExtract(tgzPath, destDir) {
+  await new Promise((resolve, reject) => {
+    const child = spawn('tar', ['-xzf', tgzPath, '-C', destDir], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    let stderr = '';
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`tar extract failed: ${stderr || `exit ${code}`}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+async function readManifestSafe(skillRoot) {
+  const p = path.join(skillRoot, 'manifest.json');
+  try {
+    const raw = await fs.readFile(p, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+async function resolveSkillSourceDir(sourcePath) {
+  const absSrc = path.resolve(sourcePath);
+  const srcStat = await fs.stat(absSrc);
+
+  if (srcStat.isFile() && absSrc.endsWith('.tgz')) {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'codemini-skill-'));
+    await runTarExtract(absSrc, tmp);
+    const candidates = ['package', ...((await fs.readdir(tmp, { withFileTypes: true }))
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name))];
+    for (const c of candidates) {
+      const dir = path.join(tmp, c);
+      try {
+        await fs.access(path.join(dir, 'SKILL.md'));
+        return { dir, cleanupDir: tmp };
+      } catch {
+        continue;
+      }
+    }
+    throw new Error('No SKILL.md found in tgz package');
+  }
+
+  if (srcStat.isFile() && path.basename(absSrc) === 'SKILL.md') {
+    return { dir: path.dirname(absSrc), cleanupDir: null };
+  }
+
+  if (srcStat.isDirectory()) {
+    await fs.access(path.join(absSrc, 'SKILL.md'));
+    return { dir: absSrc, cleanupDir: null };
+  }
+
+  throw new Error('skill install supports <skill-dir>, <SKILL.md>, or <skill.tgz>');
+}
+
+async function installSkill(sourcePath) {
+  const resolved = await resolveSkillSourceDir(sourcePath);
+  const manifest = await readManifestSafe(resolved.dir);
+  const folderName = manifest?.name || path.basename(resolved.dir);
+  const targetDir = path.join(getSkillsDir(), folderName);
+  await fs.rm(targetDir, { recursive: true, force: true });
+  await copyRecursive(resolved.dir, targetDir);
+
+  const entryFile = manifest?.entry || 'SKILL.md';
+  const entryPath = path.join(targetDir, entryFile);
+  await fs.access(entryPath);
+
+  const hash = await computeFileSha256(entryPath);
+  await upsertSkillRegistryEntry(undefined, {
+    name: folderName,
+    version: manifest?.version || '0.0.0',
+    description: manifest?.description || '',
+    enabled: true,
+    source: sourcePath,
+    entryFile,
+    sha256: hash,
+    installedAt: new Date().toISOString()
+  });
+
+  if (resolved.cleanupDir) {
+    await fs.rm(resolved.cleanupDir, { recursive: true, force: true });
+  }
+
+  return folderName;
+}
+
+async function setEnabled(name, enabled) {
+  const registry = await readSkillRegistry();
+  const idx = registry.skills.findIndex((s) => s.name === name);
+  if (idx === -1) {
+    throw new Error(`skill not found: ${name}`);
+  }
+  registry.skills[idx].enabled = enabled;
+  await writeSkillRegistry(undefined, registry);
+}
+
+async function reindexSkills() {
+  await fs.mkdir(getSkillsDir(), { recursive: true });
+  const entries = await fs.readdir(getSkillsDir(), { withFileTypes: true });
+  const registry = await readSkillRegistry();
+  const byName = new Map((registry.skills || []).map((s) => [s.name, s]));
+  const rebuilt = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    const dir = path.join(getSkillsDir(), name);
+    const manifest = await readManifestSafe(dir);
+    const entryFile = manifest?.entry || 'SKILL.md';
+    const entryPath = path.join(dir, entryFile);
+    try {
+      await fs.access(entryPath);
+    } catch {
+      continue;
+    }
+    const hash = await computeFileSha256(entryPath);
+    const prior = byName.get(name);
+    rebuilt.push({
+      name: manifest?.name || name,
+      version: manifest?.version || prior?.version || '0.0.0',
+      description: manifest?.description || prior?.description || '',
+      enabled: prior?.enabled !== false,
+      source: prior?.source || 'reindex',
+      entryFile,
+      sha256: hash,
+      installedAt: prior?.installedAt || new Date().toISOString()
+    });
+  }
+
+  await writeSkillRegistry(undefined, {
+    version: 1,
+    skills: rebuilt
+  });
+
+  return rebuilt.length;
+}
+
+function usage() {
+  console.log(`Usage:
+  codemini skill list
+  codemini skill install <path>
+  codemini skill enable <name>
+  codemini skill disable <name>
+  codemini skill inspect <name>
+  codemini skill reindex`);
+}
+
+export async function handleSkill(args) {
+  const [sub, ...rest] = args;
+  if (!sub) {
+    usage();
+    return;
+  }
+
+  if (sub === 'list') {
+    const entries = await listSkillEntries();
+    if (entries.length === 0) {
+      console.log('No installed skills');
+      return;
+    }
+    for (const item of entries) {
+      const state = item.enabled !== false ? 'enabled' : 'disabled';
+      console.log(`${item.name}@${item.version || '0.0.0'} (${state})`);
+    }
+    return;
+  }
+
+  if (sub === 'install') {
+    const sourcePath = rest[0];
+    if (!sourcePath) {
+      throw new Error('skill install requires <path>');
+    }
+    const installedName = await installSkill(sourcePath);
+    await setEnabled(installedName, true);
+    console.log(`Installed skill: ${installedName}`);
+    return;
+  }
+
+  if (sub === 'enable' || sub === 'disable') {
+    const name = rest[0];
+    if (!name) {
+      throw new Error(`skill ${sub} requires <name>`);
+    }
+    await setEnabled(name, sub === 'enable');
+    console.log(`${sub}d skill: ${name}`);
+    return;
+  }
+
+  if (sub === 'inspect') {
+    const name = rest[0];
+    if (!name) {
+      throw new Error('skill inspect requires <name>');
+    }
+    const meta = await readSkillMeta(name);
+    if (!meta.exists) {
+      throw new Error(`skill not found: ${name}`);
+    }
+    if (meta.manifest) {
+      console.log(`Manifest: ${JSON.stringify(meta.manifest, null, 2)}\n`);
+    }
+    console.log(`Path: ${meta.path}\n`);
+    console.log(meta.preview);
+    return;
+  }
+
+  if (sub === 'reindex') {
+    const count = await reindexSkills();
+    console.log(`Reindexed skills: ${count}`);
+    return;
+  }
+
+  usage();
+}

package/src/core/agent-loop.js

@@ -0,0 +1,281 @@
+function safeJsonParse(raw) {
+  if (!raw || typeof raw !== 'string') return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function clipToolResult(result, maxChars = 12000) {
+  const raw = typeof result === 'string' ? result : JSON.stringify(result);
+  if (!maxChars || raw.length <= maxChars) return raw;
+  return `${raw.slice(0, maxChars)}\n... [tool result truncated ${raw.length - maxChars} chars]`;
+}
+
+function summarizeToolResult(result) {
+  if (result === null || result === undefined) return 'no output';
+  if (typeof result === 'string') {
+    const oneLine = result.replace(/\s+/g, ' ').trim();
+    return oneLine.length > 90 ? `${oneLine.slice(0, 87)}...` : oneLine || 'empty string';
+  }
+  if (typeof result === 'object') {
+    const obj = result;
+    if (Array.isArray(obj)) return `array(${obj.length})`;
+    if ('path' in obj && 'action' in obj) {
+      const p = String(obj.path || '');
+      const action = String(obj.action || 'write');
+      const line = Number(obj.changed_line || 1);
+      const preview = String(obj.diff_preview || '')
+        .split('\n')
+        .slice(0, 3)
+        .join('\n');
+      return `${action} ${p} @L${line}${preview ? `\n${preview}` : ''}`;
+    }
+    if ('path' in obj && 'phase' in obj) {
+      const phase = String(obj.phase || '');
+      const p = String(obj.path || '');
+      const total = Number(obj.total_lines);
+      const start =
+        Number(obj.suggested_start_line || obj.start_line) > 0
+          ? Number(obj.suggested_start_line || obj.start_line)
+          : 1;
+      const end =
+        Number(obj.suggested_end_line || obj.end_line) >= start
+          ? Number(obj.suggested_end_line || obj.end_line)
+          : start;
+      const rangeText = start > 0 && end >= start ? ` lines ${start}-${end}` : '';
+      const totalText = total > 0 ? ` of ${total}` : '';
+      const errorText = obj.error ? ` (${trimInline(obj.error, 64)})` : '';
+      const truncatedText = obj.truncated ? ' [truncated]' : '';
+      return phase === 'metadata'
+        ? `metadata for ${p}${rangeText}${totalText}${errorText}`
+        : `content from ${p}${rangeText}${totalText}${truncatedText}`;
+    }
+    if ('stdout' in obj || 'stderr' in obj || 'code' in obj) {
+      const stdout = trimInline(obj.stdout || '', 96);
+      const stderr = trimInline(obj.stderr || '', 96);
+      const command = trimInline(obj.command || '', 72);
+      const lead = command ? `${command} -> ` : '';
+      if (stdout) return `${lead}exit ${obj.code ?? 0}\nstdout: ${stdout}`;
+      if (stderr) return `${lead}exit ${obj.code ?? 0}\nstderr: ${stderr}`;
+      return `${lead}exit ${obj.code ?? 0}`;
+    }
+    if ('created' in obj && Array.isArray(obj.created)) {
+      return `created ${obj.created.length} task(s)`;
+    }
+    if ('tasks' in obj && Array.isArray(obj.tasks)) {
+      return `${obj.tasks.length} task(s)`;
+    }
+    const keys = Object.keys(obj);
+    return keys.length > 0 ? `keys: ${keys.slice(0, 5).join(',')}` : 'object';
+  }
+  return String(result);
+}
+
+function trimInline(value, maxLen = 72) {
+  const s = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!s) return '';
+  if (s.length <= maxLen) return s;
+  return `${s.slice(0, maxLen - 3)}...`;
+}
+
+function formatToolDisplayName(name, args) {
+  if (name === 'read_file' || name === 'write_file') {
+    const target = trimInline(args?.path || '.', 96) || '.';
+    if (name === 'read_file') {
+      const start = Number(args?.start_line);
+      const end = Number(args?.end_line);
+      const hasRange = Number.isFinite(start) && start > 0;
+      const suffix = hasRange ? `:${start}-${Number.isFinite(end) && end >= start ? end : start}` : '';
+      return `${name}(${target}${suffix})`;
+    }
+    return `${name}(${target})`;
+  }
+  if (name === 'run_command') {
+    const command = trimInline(args?.command || '', 96);
+    return command ? `${name}(${command})` : name;
+  }
+  return name;
+}
+
+export async function runAgentLoop({
+  systemPrompt,
+  userPrompt,
+  model,
+  requestCompletion,
+  toolHandlers = {},
+  toolDefinitions = [],
+  maxSteps = 8,
+  initialMessages = [],
+  onEvent,
+  executionMode = 'auto',
+  alwaysAllowTools = [],
+  requestToolApproval,
+  toolResultMaxChars = 12000
+}) {
+  const messages = [];
+  if (systemPrompt) {
+    messages.push({ role: 'system', content: systemPrompt });
+  }
+  if (Array.isArray(initialMessages) && initialMessages.length > 0) {
+    messages.push(...initialMessages);
+  }
+  if (userPrompt) {
+    messages.push({ role: 'user', content: userPrompt });
+  }
+
+  let finalText = '';
+  let lastAssistantText = '';
+  const alwaysAllowSet = new Set((Array.isArray(alwaysAllowTools) ? alwaysAllowTools : []).map((t) => String(t)));
+
+  for (let step = 0; step < maxSteps; step += 1) {
+    if (onEvent) onEvent({ type: 'step:start', step: step + 1 });
+    const completion = await requestCompletion({
+      model,
+      messages,
+      tools: toolDefinitions
+    });
+
+    const toolCalls = Array.isArray(completion.toolCalls) ? completion.toolCalls : [];
+    const assistantText = completion.text || '';
+    lastAssistantText = assistantText || lastAssistantText;
+
+    const assistantMessage = { role: 'assistant', content: assistantText };
+    if (toolCalls.length > 0) {
+      assistantMessage.tool_calls = toolCalls.map((tc) => ({
+        id: tc.id,
+        type: 'function',
+        function: { name: tc.name, arguments: tc.arguments || '{}' }
+      }));
+    }
+    messages.push(assistantMessage);
+    if (onEvent) {
+      onEvent({
+        type: 'assistant:response',
+        step: step + 1,
+        text: assistantText,
+        toolCalls: toolCalls.map((tc) => tc.name),
+        assistantMessage
+      });
+    }
+
+    if (toolCalls.length === 0) {
+      finalText = assistantText;
+      return { text: finalText, messages, steps: step + 1 };
+    }
+
+    if (executionMode === 'plan') {
+      finalText = `${assistantText || ''}\n\n[plan mode] ${toolCalls.length} tool call(s) were planned but not executed.`;
+      return { text: finalText.trim(), messages, steps: step + 1 };
+    }
+
+    for (const call of toolCalls) {
+      const args = safeJsonParse(call.arguments);
+      const displayName = formatToolDisplayName(call.name, args);
+      const startedAt = Date.now();
+      let approved = true;
+      if (executionMode === 'normal' && !alwaysAllowSet.has(call.name)) {
+        approved = false;
+        if (typeof requestToolApproval === 'function') {
+          const decision = await requestToolApproval({
+            id: call.id,
+            name: call.name,
+            displayName,
+            arguments: args
+          });
+          approved = Boolean(decision?.approved);
+        }
+      }
+
+      if (!approved) {
+        if (onEvent) onEvent({ type: 'tool:blocked', name: displayName, id: call.id });
+        const blockedMessage = {
+          role: 'tool',
+          tool_call_id: call.id,
+          content: JSON.stringify({ blocked: true, reason: 'Tool call requires approval in normal mode' })
+        };
+        messages.push(blockedMessage);
+        if (onEvent) {
+          onEvent({
+            type: 'tool:result',
+            name: displayName,
+            id: call.id,
+            content: blockedMessage.content,
+            blocked: true
+          });
+        }
+        continue;
+      }
+
+      if (onEvent) onEvent({ type: 'tool:start', name: displayName, id: call.id });
+      const handler = toolHandlers[call.name];
+      if (!handler) {
+        throw new Error(`Unknown tool: ${call.name}`);
+      }
+      let toolResult;
+      try {
+        toolResult = await handler(args);
+      } catch (error) {
+        const durationMs = Date.now() - startedAt;
+        const message = error instanceof Error ? error.message : String(error);
+        if (onEvent) {
+          onEvent({
+            type: 'tool:error',
+            name: displayName,
+            id: call.id,
+            durationMs,
+            summary: trimInline(message, 120)
+          });
+        }
+        const toolMessage = {
+          role: 'tool',
+          tool_call_id: call.id,
+          content: clipToolResult({ error: message }, toolResultMaxChars)
+        };
+        messages.push(toolMessage);
+        if (onEvent) {
+          onEvent({
+            type: 'tool:result',
+            name: displayName,
+            id: call.id,
+            content: toolMessage.content,
+            error: true
+          });
+        }
+        continue;
+      }
+      const durationMs = Date.now() - startedAt;
+      if (onEvent) {
+        onEvent({
+          type: 'tool:end',
+          name: displayName,
+          id: call.id,
+          durationMs,
+          summary: summarizeToolResult(toolResult)
+        });
+      }
+      const toolMessage = {
+        role: 'tool',
+        tool_call_id: call.id,
+        content: clipToolResult(toolResult, toolResultMaxChars)
+      };
+      messages.push(toolMessage);
+      if (onEvent) {
+        onEvent({
+          type: 'tool:result',
+          name: displayName,
+          id: call.id,
+          content: toolMessage.content
+        });
+      }
+    }
+  }
+
+  const fallback = lastAssistantText || 'Stopped before final response.';
+  return {
+    text: `${fallback}\n\n[stopped] Reached max tool steps (${maxSteps}). Try a narrower prompt or increase execution.max_steps.`,
+    messages,
+    steps: maxSteps
+  };
+}