@soleri/cli 1.9.0 → 1.10.1

package/src/commands/skills.ts

@@ -0,0 +1,191 @@
+/**
+ * Skills CLI — convenience aliases for `soleri pack --type skills`.
+ *
+ * Provides `soleri skills list|install|remove|info` as thin wrappers
+ * around the unified pack system.
+ */
+
+import { join } from 'node:path';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import type { Command } from 'commander';
+import * as p from '@clack/prompts';
+import { PackLockfile, inferPackType, resolvePack } from '@soleri/core';
+import type { LockEntry, PackSource } from '@soleri/core';
+import { detectAgent } from '../utils/agent-context.js';
+
+const LOCKFILE_NAME = 'soleri.lock';
+
+function getLockfilePath(): string {
+  const ctx = detectAgent();
+  if (!ctx) {
+    p.log.error('No agent project detected in current directory.');
+    process.exit(1);
+  }
+  return join(ctx.agentPath, LOCKFILE_NAME);
+}
+
+export function registerSkills(program: Command): void {
+  const skills = program
+    .command('skills')
+    .description('Manage skill packs (alias for pack --type skills)');
+
+  // ─── list ──────────────────────────────────────────────────
+  skills
+    .command('list')
+    .description('List installed skill packs')
+    .action(() => {
+      const lockfile = new PackLockfile(getLockfilePath());
+      const entries = lockfile.list().filter((e) => e.type === 'skills' || e.type === 'bundle');
+
+      if (entries.length === 0) {
+        p.log.info('No skill packs installed.');
+        return;
+      }
+
+      p.log.info(`${entries.length} skill pack(s) installed:\n`);
+      for (const entry of entries) {
+        const badge =
+          entry.source === 'built-in' ? ' [built-in]' : entry.source === 'npm' ? ' [npm]' : '';
+        console.log(`  ${entry.id}@${entry.version}${badge}`);
+        if (entry.skills.length > 0) console.log(`    skills: ${entry.skills.join(', ')}`);
+      }
+    });
+
+  // ─── install ───────────────────────────────────────────────
+  skills
+    .command('install')
+    .argument('<pack>', 'Skill pack name, path, or npm package')
+    .option('--version <ver>', 'Specific version to install')
+    .description('Install a skill pack')
+    .action(async (packName: string, opts: { version?: string }) => {
+      const lockfilePath = getLockfilePath();
+      const lockfile = new PackLockfile(lockfilePath);
+      const ctx = detectAgent();
+      if (!ctx) return;
+
+      if (lockfile.has(packName)) {
+        p.log.warn(`Pack "${packName}" is already installed.`);
+        return;
+      }
+
+      const s = p.spinner();
+      s.start(`Resolving skill pack: ${packName}...`);
+
+      try {
+        const resolved = resolvePack(packName, {
+          builtinDirs: getBuiltinDirs(ctx.agentPath),
+          version: opts.version,
+        });
+
+        const manifestPath = join(resolved.directory, 'soleri-pack.json');
+        if (!existsSync(manifestPath)) {
+          s.stop('Install failed');
+          p.log.error(`No soleri-pack.json found in ${resolved.directory}`);
+          process.exit(1);
+          return;
+        }
+
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+        const packType = inferPackType(manifest);
+
+        if (packType !== 'skills' && packType !== 'bundle') {
+          s.stop('Install failed');
+          p.log.error(`Pack "${packName}" is type "${packType}", not a skill pack.`);
+          process.exit(1);
+          return;
+        }
+
+        const skillsDir = join(resolved.directory, manifest.skills?.dir ?? 'skills');
+        const skillsList = existsSync(skillsDir) ? listMdFiles(skillsDir) : [];
+
+        const entry: LockEntry = {
+          id: manifest.id,
+          version: manifest.version,
+          type: packType,
+          source: resolved.source as PackSource,
+          directory: resolved.directory,
+          integrity: PackLockfile.computeIntegrity(manifestPath),
+          installedAt: new Date().toISOString(),
+          vaultEntries: 0,
+          skills: skillsList,
+          hooks: [],
+          facadesRegistered: false,
+        };
+
+        lockfile.set(entry);
+        lockfile.save();
+
+        s.stop(`Installed ${manifest.id}@${manifest.version}`);
+        if (skillsList.length > 0) {
+          p.log.info(`  Skills: ${skillsList.join(', ')}`);
+        }
+      } catch (err) {
+        s.stop('Install failed');
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  // ─── remove ────────────────────────────────────────────────
+  skills
+    .command('remove')
+    .argument('<packId>', 'Skill pack ID to remove')
+    .description('Remove a skill pack')
+    .action((packId: string) => {
+      const lockfile = new PackLockfile(getLockfilePath());
+
+      if (!lockfile.has(packId)) {
+        p.log.error(`Skill pack "${packId}" is not installed.`);
+        process.exit(1);
+      }
+
+      lockfile.remove(packId);
+      lockfile.save();
+      p.log.success(`Removed ${packId}`);
+    });
+
+  // ─── info ──────────────────────────────────────────────────
+  skills
+    .command('info')
+    .argument('<packId>', 'Skill pack ID')
+    .description('Show info about a skill pack')
+    .action((packId: string) => {
+      const lockfile = new PackLockfile(getLockfilePath());
+      const entry = lockfile.get(packId);
+
+      if (!entry) {
+        p.log.error(`Skill pack "${packId}" is not installed.`);
+        process.exit(1);
+        return;
+      }
+
+      console.log(`\n  Pack:      ${entry.id}`);
+      console.log(`  Version:   ${entry.version}`);
+      console.log(`  Source:    ${entry.source}`);
+      console.log(`  Installed: ${entry.installedAt}`);
+      if (entry.skills.length > 0) console.log(`  Skills:    ${entry.skills.join(', ')}`);
+      console.log('');
+    });
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+function getBuiltinDirs(agentPath: string): string[] {
+  const dirs: string[] = [];
+  const nmPacks = join(agentPath, 'node_modules', '@soleri');
+  if (existsSync(nmPacks)) {
+    dirs.push(nmPacks);
+  }
+  return dirs;
+}
+
+function listMdFiles(dir: string): string[] {
+  try {
+    const { basename } = require('node:path');
+    return readdirSync(dir)
+      .filter((f: string) => f.endsWith('.md'))
+      .map((f: string) => basename(f, '.md'));
+  } catch {
+    return [];
+  }
+}

package/src/commands/uninstall.ts

@@ -0,0 +1,93 @@
+import type { Command } from 'commander';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import * as p from '@clack/prompts';
+import { detectAgent } from '../utils/agent-context.js';
+
+type Target = 'claude' | 'codex' | 'both';
+
+function uninstallClaude(agentId: string): void {
+  const configPath = join(homedir(), '.claude.json');
+
+  if (!existsSync(configPath)) {
+    p.log.warn(`~/.claude.json not found — nothing to remove.`);
+    return;
+  }
+
+  let config: Record<string, unknown>;
+  try {
+    config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch {
+    p.log.error(`Failed to parse ${configPath}.`);
+    process.exit(1);
+  }
+
+  const servers = config.mcpServers as Record<string, unknown> | undefined;
+  if (!servers || !(agentId in servers)) {
+    p.log.warn(`${agentId} not found in ~/.claude.json — nothing to remove.`);
+    return;
+  }
+
+  delete servers[agentId];
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  p.log.success(`Removed ${agentId} from ~/.claude.json`);
+}
+
+function uninstallCodex(agentId: string): void {
+  const configPath = join(homedir(), '.codex', 'config.toml');
+
+  if (!existsSync(configPath)) {
+    p.log.warn(`~/.codex/config.toml not found — nothing to remove.`);
+    return;
+  }
+
+  let content = readFileSync(configPath, 'utf-8');
+
+  const sectionRegex = new RegExp(`\\[mcp_servers\\.${escapeRegExp(agentId)}\\][^\\[]*`, 's');
+
+  if (!sectionRegex.test(content)) {
+    p.log.warn(`${agentId} not found in ~/.codex/config.toml — nothing to remove.`);
+    return;
+  }
+
+  content = content.replace(sectionRegex, '').trim();
+  writeFileSync(configPath, content + '\n', 'utf-8');
+  p.log.success(`Removed ${agentId} from ~/.codex/config.toml`);
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export function registerUninstall(program: Command): void {
+  program
+    .command('uninstall')
+    .argument('[dir]', 'Agent directory (defaults to cwd)')
+    .option('--target <target>', 'Registration target: claude, codex, or both', 'claude')
+    .description('Remove agent MCP server entry from editor config')
+    .action(async (dir?: string, opts?: { target?: string }) => {
+      const resolvedDir = dir ? resolve(dir) : undefined;
+      const ctx = detectAgent(resolvedDir);
+
+      if (!ctx) {
+        p.log.error('Not in an agent project. Run from an agent directory or pass its path.');
+        process.exit(1);
+      }
+
+      const target = (opts?.target ?? 'claude') as Target;
+
+      if (target !== 'claude' && target !== 'codex' && target !== 'both') {
+        p.log.error(`Invalid target "${target}". Use: claude, codex, or both`);
+        process.exit(1);
+      }
+
+      if (target === 'claude' || target === 'both') {
+        uninstallClaude(ctx.agentId);
+      }
+
+      if (target === 'codex' || target === 'both') {
+        uninstallCodex(ctx.agentId);
+      }
+    });
+}

package/src/hook-packs/installer.ts

@@ -1,7 +1,7 @@
 /**
  * Hook pack installer — copies hookify files to ~/.claude/ (global) or project .claude/ (local).
  */
-import { existsSync, copyFileSync, unlinkSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, copyFileSync, unlinkSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { getPack } from './registry.js';
@@ -126,20 +126,3 @@ export function isPackInstalled(
   if (present === pack.manifest.hooks.length) return true;
   return 'partial';
 }
-
-/**
- * Get the installed version of a hook from its file header.
- * Returns null if no version found or file doesn't exist.
- */
-export function getInstalledHookVersion(
-  hook: string,
-  options?: { projectDir?: string },
-): string | null {
-  const claudeDir = resolveClaudeDir(options?.projectDir);
-  const filePath = join(claudeDir, `hookify.${hook}.local.md`);
-  if (!existsSync(filePath)) return null;
-
-  const content = readFileSync(filePath, 'utf-8');
-  const match = content.match(/^# Version: (.+)$/m);
-  return match ? match[1] : null;
-}

package/src/hook-packs/registry.ts

@@ -6,7 +6,7 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 
-export interface HookPackManifest {
+interface HookPackManifest {
   name: string;
   description: string;
   hooks: string[];

package/src/main.ts

@@ -13,16 +13,52 @@ import { registerGovernance } from './commands/governance.js';
 import { registerTest } from './commands/test.js';
 import { registerUpgrade } from './commands/upgrade.js';
 import { registerExtend } from './commands/extend.js';
+import { registerInstall } from './commands/install.js';
+import { registerUninstall } from './commands/uninstall.js';
+import { registerPack } from './commands/pack.js';
+import { registerSkills } from './commands/skills.js';
+import { registerAgent } from './commands/agent.js';
 
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
 
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+
+function showWelcome(): void {
+  console.log();
+  console.log(`  ${BOLD}${CYAN}soleri${RESET} ${DIM}v${version}${RESET}`);
+  console.log(`  ${DIM}The agent forge${RESET}`);
+  console.log();
+  console.log(`  ${GREEN}Get started${RESET}`);
+  console.log(`    ${BOLD}soleri create${RESET}        Scaffold a new agent`);
+  console.log(`    ${BOLD}soleri doctor${RESET}        Check system health`);
+  console.log();
+  console.log(`  ${YELLOW}Working on an agent${RESET}`);
+  console.log(`    ${BOLD}soleri dev${RESET}           Run in development mode`);
+  console.log(`    ${BOLD}soleri test${RESET}          Run agent tests`);
+  console.log(`    ${BOLD}soleri add-domain${RESET}    Add a knowledge domain`);
+  console.log(`    ${BOLD}soleri hooks${RESET}         Manage editor hooks`);
+  console.log(`    ${BOLD}soleri install${RESET}       Register agent as MCP server`);
+  console.log(`    ${BOLD}soleri uninstall${RESET}     Remove agent MCP server entry`);
+  console.log();
+  console.log(`  ${DIM}Run ${BOLD}soleri --help${RESET}${DIM} for all commands${RESET}`);
+  console.log();
+}
+
 const program = new Command();
 
 program
   .name('soleri')
   .description('Developer CLI for creating and managing Soleri AI agents')
-  .version(version);
+  .version(version)
+  .action(() => {
+    showWelcome();
+  });
 
 registerCreate(program);
 registerList(program);
@@ -35,5 +71,10 @@ registerGovernance(program);
 registerTest(program);
 registerUpgrade(program);
 registerExtend(program);
+registerInstall(program);
+registerUninstall(program);
+registerPack(program);
+registerSkills(program);
+registerAgent(program);
 
 program.parse();