@soleri/cli 9.3.1 → 9.5.0

package/src/commands/pack.ts

@@ -13,6 +13,18 @@ import type { Command } from 'commander';
 import * as p from '@clack/prompts';
 import { PackLockfile, inferPackType, resolvePack, checkNpmVersion } from '@soleri/core';
 import type { LockEntry, PackSource } from '@soleri/core';
+
+// ─── Tier display helpers ────────────────────────────────────────────
+
+const TIER_BADGES: Record<string, string> = {
+  default: '[default]',
+  community: '[community]',
+  premium: '[premium]',
+};
+
+function tierBadge(tier?: string): string {
+  return TIER_BADGES[tier ?? 'community'] ?? '[community]';
+}
 import { detectAgent } from '../utils/agent-context.js';
 
 const LOCKFILE_NAME = 'soleri.lock';
@@ -45,14 +57,18 @@ export function registerPack(program: Command): void {
   pack
     .command('list')
     .option('--type <type>', 'Filter by pack type (hooks, skills, knowledge, domain, bundle)')
+    .option('--tier <tier>', 'Filter by tier (default, community, premium)')
     .description('List installed packs')
-    .action((opts: { type?: string }) => {
+    .action((opts: { type?: string; tier?: string }) => {
       const lockfile = new PackLockfile(getLockfilePath());
       let entries = lockfile.list();
 
       if (opts.type) {
         entries = entries.filter((e) => e.type === opts.type);
       }
+      if (opts.tier) {
+        entries = entries.filter((e) => (e.tier ?? 'community') === opts.tier);
+      }
 
       if (entries.length === 0) {
         p.log.info('No packs installed.');
@@ -61,9 +77,10 @@ export function registerPack(program: Command): void {
 
       p.log.info(`${entries.length} pack(s) installed:\n`);
       for (const entry of entries) {
-        const badge =
+        const source =
           entry.source === 'built-in' ? ' [built-in]' : entry.source === 'npm' ? ' [npm]' : '';
-        console.log(`  ${entry.id}@${entry.version}  ${entry.type}${badge}`);
+        const tier = ` ${tierBadge(entry.tier)}`;
+        console.log(`  ${entry.id}@${entry.version}  ${entry.type}${tier}${source}`);
         if (entry.vaultEntries > 0) console.log(`    vault: ${entry.vaultEntries} entries`);
         if (entry.skills.length > 0) console.log(`    skills: ${entry.skills.join(', ')}`);
         if (entry.hooks.length > 0) console.log(`    hooks: ${entry.hooks.join(', ')}`);
@@ -163,6 +180,7 @@ export function registerPack(program: Command): void {
             skills,
             hooks,
             facadesRegistered: (manifest.facades?.length ?? 0) > 0,
+            tier: manifest.tier ?? 'community',
           };
 
           lockfile.set(entry);
@@ -219,9 +237,14 @@ export function registerPack(program: Command): void {
         return;
       }
 
+      const tierLabel = entry.tier ?? 'community';
+      const tierNote =
+        tierLabel === 'premium' ? ' (currently unlocked — premium platform coming soon)' : '';
+
       console.log(`\n  Pack:      ${entry.id}`);
       console.log(`  Version:   ${entry.version}`);
       console.log(`  Type:      ${entry.type}`);
+      console.log(`  Tier:      ${tierLabel}${tierNote}`);
       console.log(`  Source:    ${entry.source}`);
       console.log(`  Directory: ${entry.directory}`);
       console.log(`  Installed: ${entry.installedAt}`);
@@ -378,7 +401,16 @@ export function registerPack(program: Command): void {
         return;
       }
 
-      let total = 0;
+      // Collect all packs with their tier
+      const allPacks: Array<{
+        id: string;
+        version: string;
+        description: string;
+        domains: string;
+        tier: string;
+        category: string;
+      }> = [];
+
       for (const baseDir of searchDirs) {
         const categories = readdirSync(baseDir, { withFileTypes: true })
           .filter((d) => d.isDirectory())
@@ -390,18 +422,19 @@ export function registerPack(program: Command): void {
             (d) => d.isDirectory() && existsSync(join(categoryDir, d.name, 'soleri-pack.json')),
           );
 
-          if (packs.length === 0) continue;
-
-          console.log(`\n  ${category}/`);
           for (const pk of packs) {
             try {
               const manifest = JSON.parse(
                 readFileSync(join(categoryDir, pk.name, 'soleri-pack.json'), 'utf-8'),
               );
-              const domains = (manifest.domains as string[])?.join(', ') || '—';
-              console.log(`    ${manifest.id}@${manifest.version}  ${manifest.description || ''}`);
-              console.log(`      domains: ${domains}`);
-              total++;
+              allPacks.push({
+                id: manifest.id,
+                version: manifest.version,
+                description: manifest.description || '',
+                domains: (manifest.domains as string[])?.join(', ') || '—',
+                tier: manifest.tier ?? 'community',
+                category,
+              });
             } catch {
               // skip malformed packs
             }
@@ -409,11 +442,31 @@ export function registerPack(program: Command): void {
         }
       }
 
-      if (total === 0) {
+      if (allPacks.length === 0) {
         p.log.info('No packs found.');
-      } else {
-        console.log(`\n  ${total} pack(s) available.\n`);
+        return;
       }
+
+      // Group by tier and display
+      const tierOrder: Array<{ key: string; label: string }> = [
+        { key: 'default', label: 'Default (included with Soleri)' },
+        { key: 'community', label: 'Community (free)' },
+        { key: 'premium', label: 'Premium (included — premium platform coming soon)' },
+      ];
+
+      for (const { key, label } of tierOrder) {
+        const tierPacks = allPacks.filter((pk) => pk.tier === key);
+        if (tierPacks.length === 0) continue;
+
+        console.log(`\n  ${label}`);
+        console.log(`  ${'─'.repeat(label.length)}`);
+        for (const pk of tierPacks) {
+          console.log(`    ${pk.id}@${pk.version}  ${pk.description}`);
+          console.log(`      domains: ${pk.domains}`);
+        }
+      }
+
+      console.log(`\n  ${allPacks.length} pack(s) available.\n`);
     });
 
   // ─── create ─────────────────────────────────────────────────
@@ -441,6 +494,18 @@ export function registerPack(program: Command): void {
       });
       if (p.isCancel(description)) return;
 
+      const tier = await p.select({
+        message: 'Pack tier:',
+        options: [
+          { value: 'community', label: 'Community — free, published to npm' },
+          {
+            value: 'premium',
+            label: 'Premium — requires Soleri platform account (coming soon)',
+          },
+        ],
+      });
+      if (p.isCancel(tier)) return;
+
       const author = await p.text({ message: 'Author:', placeholder: '@username' });
       if (p.isCancel(author)) return;
 
@@ -454,6 +519,7 @@ export function registerPack(program: Command): void {
         id: name,
         version: '1.0.0',
         description: description || '',
+        tier: tier || 'community',
         author: author || '',
         license: 'MIT',
         soleri: '>=2.0.0',

package/src/commands/staging.ts

@@ -4,9 +4,12 @@ import { join, relative } from 'node:path';
 import { homedir } from 'node:os';
 import * as log from '../utils/logger.js';
 
-const STAGING_ROOT = join(homedir(), '.soleri', 'staging');
+export const STAGING_ROOT = join(homedir(), '.soleri', 'staging');
 
-interface StagedEntry {
+/** Default max age for stale staging entries (7 days). */
+const DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+export interface StagedEntry {
   id: string;
   timestamp: string;
   path: string;
@@ -17,7 +20,7 @@ interface StagedEntry {
 /**
  * Walk a directory tree and collect all items with their relative paths.
  */
-function walkDir(dir: string, base: string): { relPath: string; size: number }[] {
+export function walkDir(dir: string, base: string): { relPath: string; size: number }[] {
   const results: { relPath: string; size: number }[] = [];
   if (!existsSync(dir)) return results;
 
@@ -38,7 +41,7 @@ function walkDir(dir: string, base: string): { relPath: string; size: number }[]
 /**
  * List all staged entries.
  */
-function listStaged(): StagedEntry[] {
+export function listStaged(): StagedEntry[] {
   if (!existsSync(STAGING_ROOT)) return [];
 
   const entries: StagedEntry[] = [];
@@ -66,7 +69,7 @@ function listStaged(): StagedEntry[] {
 /**
  * Parse a duration string like "7d", "24h", "30m" into milliseconds.
  */
-function parseDuration(duration: string): number | null {
+export function parseDuration(duration: string): number | null {
   const match = duration.match(/^(\d+)(d|h|m)$/);
   if (!match) return null;
 
@@ -85,12 +88,78 @@ function parseDuration(duration: string): number | null {
   }
 }
 
-function formatSize(bytes: number): string {
+export function formatSize(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
+// ─── Reusable Utility Functions ──────────────────────────────────────
+
+export interface StaleStagingInfo {
+  /** Entries older than maxAge. */
+  staleEntries: StagedEntry[];
+  /** Total bytes across stale entries. */
+  totalBytes: number;
+  /** Human-readable total size. */
+  totalSize: string;
+  /** Number of stale entries. */
+  count: number;
+}
+
+/**
+ * Check for staging entries older than a given age.
+ * Pure function — no I/O side effects beyond reading the filesystem.
+ *
+ * @param maxAgeMs - Maximum age in milliseconds (default: 7 days)
+ * @returns Info about stale entries, or null if none found.
+ */
+export function getStaleStagingInfo(
+  maxAgeMs: number = DEFAULT_MAX_AGE_MS,
+): StaleStagingInfo | null {
+  const entries = listStaged();
+  if (entries.length === 0) return null;
+
+  const cutoff = Date.now() - maxAgeMs;
+  const staleEntries = entries.filter((entry) => {
+    try {
+      const stat = statSync(entry.path);
+      return stat.mtimeMs < cutoff;
+    } catch {
+      return false;
+    }
+  });
+
+  if (staleEntries.length === 0) return null;
+
+  const totalBytes = staleEntries.reduce((sum, e) => sum + e.size, 0);
+  return {
+    staleEntries,
+    totalBytes,
+    totalSize: formatSize(totalBytes),
+    count: staleEntries.length,
+  };
+}
+
+/**
+ * Purge stale staging entries. Returns the number of entries removed.
+ *
+ * @param entries - Entries to purge (from getStaleStagingInfo().staleEntries)
+ * @returns Number of entries successfully removed.
+ */
+export function purgeStagingEntries(entries: StagedEntry[]): number {
+  let removed = 0;
+  for (const entry of entries) {
+    try {
+      rmSync(entry.path, { recursive: true, force: true });
+      removed++;
+    } catch {
+      // Skip failures silently — entry may have been removed concurrently
+    }
+  }
+  return removed;
+}
+
 export function registerStaging(program: Command): void {
   const staging = program.command('staging').description('Manage anti-deletion staging folder');
 
@@ -161,25 +230,31 @@ export function registerStaging(program: Command): void {
     });
 
   staging
-    .command('purge')
-    .option('--older-than <duration>', 'Only purge snapshots older than duration (e.g. 7d, 24h)')
-    .description('Permanently delete staged files')
-    .action((opts: { olderThan?: string }) => {
+    .command('clean')
+    .option(
+      '--older-than <duration>',
+      'Only remove snapshots older than duration (default: 7d)',
+      '7d',
+    )
+    .option('--all', 'Remove all snapshots regardless of age')
+    .option('--dry-run', 'Show what would be removed without deleting')
+    .description('Remove staging backups older than 7 days (or --all)')
+    .action((opts: { olderThan: string; all?: boolean; dryRun?: boolean }) => {
       if (!existsSync(STAGING_ROOT)) {
-        log.info('No staging directory found. Nothing to purge.');
+        log.info('No staging directory found. Nothing to clean.');
         return;
       }
 
       const entries = listStaged();
 
       if (entries.length === 0) {
-        log.info('No staged files to purge.');
+        log.info('No staged files to clean.');
         return;
       }
 
-      let toPurge = entries;
+      let toClean = entries;
 
-      if (opts.olderThan) {
+      if (!opts.all) {
         const maxAge = parseDuration(opts.olderThan);
         if (!maxAge) {
           log.fail(`Invalid duration: "${opts.olderThan}". Use format like 7d, 24h, 30m`);
@@ -187,22 +262,70 @@ export function registerStaging(program: Command): void {
         }
 
         const cutoff = Date.now() - maxAge;
-        toPurge = entries.filter((entry) => {
+        toClean = entries.filter((entry) => {
           const stat = statSync(entry.path);
           return stat.mtimeMs < cutoff;
         });
       }
 
-      if (toPurge.length === 0) {
-        log.info('No snapshots match the purge criteria.');
+      if (toClean.length === 0) {
+        log.info('No snapshots match the clean criteria.');
         return;
       }
 
-      for (const entry of toPurge) {
+      if (opts.dryRun) {
+        log.heading('Dry run — would remove:');
+        for (const entry of toClean) {
+          log.warn(`${entry.id}`, formatSize(entry.size));
+        }
+        log.info(`Would remove ${toClean.length} staging snapshot(s)`);
+        return;
+      }
+
+      for (const entry of toClean) {
         rmSync(entry.path, { recursive: true, force: true });
-        log.warn(`Purged ${entry.id}`);
+        log.warn(`Removed ${entry.id}`);
+      }
+
+      log.info(`Removed ${toClean.length} staging snapshot(s)`);
+    });
+
+  staging
+    .command('cleanup')
+    .option('--older-than <duration>', 'Max age for stale entries (default: 7d)', '7d')
+    .option('--yes', 'Skip confirmation prompt')
+    .description('Check for and remove stale staging backups (default: older than 7 days)')
+    .action((opts: { olderThan: string; yes?: boolean }) => {
+      const maxAge = parseDuration(opts.olderThan);
+      if (!maxAge) {
+        log.fail(`Invalid duration: "${opts.olderThan}". Use format like 7d, 24h, 30m`);
+        process.exit(1);
+      }
+
+      const info = getStaleStagingInfo(maxAge);
+
+      if (!info) {
+        log.info('No stale staging backups found.');
+        return;
+      }
+
+      log.heading('Stale Staging Backups');
+      log.info(
+        `Found ${info.count} staging backup(s) older than ${opts.olderThan} (${info.totalSize}).`,
+      );
+
+      for (const entry of info.staleEntries) {
+        log.dim(`  ${entry.id}  ${formatSize(entry.size)}`);
+      }
+
+      if (!opts.yes) {
+        log.info(
+          `Run with --yes to remove, or use: soleri staging purge --older-than ${opts.olderThan}`,
+        );
+        return;
       }
 
-      log.info(`Purged ${toPurge.length} staging snapshot(s)`);
+      const removed = purgeStagingEntries(info.staleEntries);
+      log.pass(`Cleaned up ${removed} stale staging backup(s), freed ${info.totalSize}.`);
     });
 }

package/src/commands/yolo.ts

@@ -0,0 +1,103 @@
+import { spawn } from 'node:child_process';
+import type { Command } from 'commander';
+import { isPackInstalled, installPack } from '../hook-packs/installer.js';
+import { getPack } from '../hook-packs/registry.js';
+import * as log from '../utils/logger.js';
+
+const YOLO_PACK = 'yolo-safety';
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+
+export function registerYolo(program: Command): void {
+  program
+    .command('yolo')
+    .description('Launch Claude Code in YOLO mode with safety guardrails')
+    .option('--dry-run', 'Show what would happen without launching Claude')
+    .option('--project', 'Install safety hooks to project .claude/ instead of global ~/.claude/')
+    .action((opts: { dryRun?: boolean; project?: boolean }) => {
+      runYolo(opts);
+    });
+}
+
+function runYolo(opts: { dryRun?: boolean; project?: boolean }): void {
+  // 1. Verify the yolo-safety pack exists in registry
+  const pack = getPack(YOLO_PACK);
+  if (!pack) {
+    log.fail(`Hook pack "${YOLO_PACK}" not found in registry. Is @soleri/cli up to date?`);
+    process.exit(1);
+  }
+
+  // 2. Check if already installed, install if not
+  const projectDir = opts.project ? process.cwd() : undefined;
+  const installed = isPackInstalled(YOLO_PACK, { projectDir });
+
+  if (installed === true) {
+    log.pass(`${YOLO_PACK} hook pack already installed`);
+  } else {
+    if (installed === 'partial') {
+      log.warn(`${YOLO_PACK} hook pack partially installed — reinstalling`);
+    }
+    const result = installPack(YOLO_PACK, { projectDir });
+    const target = opts.project ? '.claude/' : '~/.claude/';
+    for (const script of result.scripts) {
+      log.pass(`Installed ${script} → ${target}`);
+    }
+    for (const lc of result.lifecycleHooks) {
+      log.pass(`Registered lifecycle hook: ${lc}`);
+    }
+    const totalInstalled =
+      result.installed.length + result.scripts.length + result.lifecycleHooks.length;
+    if (totalInstalled > 0) {
+      log.pass(`${YOLO_PACK} hook pack installed (${totalInstalled} items)`);
+    }
+  }
+
+  // 3. Print safety warning
+  console.log();
+  console.log(`  ${RED}${BOLD}⚡ YOLO MODE${RESET}`);
+  console.log();
+  console.log(
+    `  ${YELLOW}Approval gates skipped — Claude will execute commands without asking.${RESET}`,
+  );
+  console.log(
+    `  ${YELLOW}Safety hooks active — destructive commands (rm, git push --force,${RESET}`,
+  );
+  console.log(`  ${YELLOW}git reset --hard, drop table, docker rm) are intercepted.${RESET}`);
+  console.log();
+
+  if (opts.dryRun) {
+    log.info('Dry run — would launch:');
+    log.dim('  claude --dangerously-skip-permissions');
+    return;
+  }
+
+  // 4. Launch Claude Code with permissions skipped
+  log.info('Launching Claude Code in YOLO mode...');
+  console.log();
+
+  const child = spawn('claude', ['--dangerously-skip-permissions'], {
+    stdio: 'inherit',
+    env: { ...process.env },
+  });
+
+  child.on('error', (err) => {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      log.fail(
+        'Claude CLI not found. Install it first: https://docs.anthropic.com/en/docs/claude-code',
+      );
+    } else {
+      log.fail(`Failed to launch Claude: ${err.message}`);
+    }
+    process.exit(1);
+  });
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.exit(1);
+    }
+    process.exit(code ?? 0);
+  });
+}

package/src/hook-packs/converter/README.md

@@ -0,0 +1,99 @@
+# Skill-to-Hook Conversion System
+
+Convert repeatedly-invoked skills into automated Claude Code hooks. Hooks fire automatically on matching events — no manual invocation, no LLM round trip.
+
+## Workflow
+
+```
+Score → Convert → Test → Graduate
+```
+
+### 1. Score the Candidate
+
+Evaluate 4 dimensions (each HIGH or LOW):
+
+| Dimension             | HIGH when...                                             |
+| --------------------- | -------------------------------------------------------- |
+| **Frequency**         | 3+ manual calls per session for same event type          |
+| **Event Correlation** | Skill consistently triggers on a recognizable hook event |
+| **Determinism**       | Skill produces consistent, non-exploratory guidance      |
+| **Autonomy**          | Skill requires no interactive user decisions             |
+
+**Threshold:** 3/4 HIGH = candidate for conversion.
+
+```typescript
+import { scoreCandidateForConversion } from '@soleri/core';
+
+const result = scoreCandidateForConversion({
+  frequency: 'HIGH',
+  eventCorrelation: 'HIGH',
+  determinism: 'HIGH',
+  autonomy: 'LOW',
+});
+// result.candidate === true (3/4)
+```
+
+### 2. Convert
+
+```bash
+soleri hooks convert marketing-research \
+  --event PreToolUse \
+  --matcher "Write|Edit" \
+  --pattern "**/marketing/**" \
+  --action remind \
+  --message "Check brand guidelines and A/B testing data"
+```
+
+This creates a hook pack with `manifest.json` and a POSIX shell script.
+
+### 3. Test
+
+```bash
+soleri hooks test marketing-research
+```
+
+Runs 15 fixtures (5 matching + 10 non-matching) against the hook script. Reports false positives and false negatives. **Zero false positives required before graduation.**
+
+### 4. Graduate
+
+Hooks default to `remind` (gentle context injection). After proving zero false positives:
+
+```bash
+soleri hooks promote marketing-research   # remind → warn
+soleri hooks promote marketing-research   # warn → block
+```
+
+To step back:
+
+```bash
+soleri hooks demote marketing-research    # block → warn
+```
+
+## Hook Events
+
+| Event          | When it fires                                |
+| -------------- | -------------------------------------------- |
+| `PreToolUse`   | Before a tool call (Write, Edit, Bash, etc.) |
+| `PostToolUse`  | After a tool call completes                  |
+| `PreCompact`   | Before context compaction                    |
+| `Notification` | On notification events                       |
+| `Stop`         | When the session ends                        |
+
+## Action Levels
+
+| Level    | Behavior                              |
+| -------- | ------------------------------------- |
+| `remind` | Inject context, don't block (default) |
+| `warn`   | Inject warning context, don't block   |
+| `block`  | Block the operation with a reason     |
+
+## CLI Commands
+
+| Command                           | Description                           |
+| --------------------------------- | ------------------------------------- |
+| `soleri hooks convert <name>`     | Create a new hook pack from a skill   |
+| `soleri hooks test <pack>`        | Validate a hook pack against fixtures |
+| `soleri hooks promote <pack>`     | Step up action level                  |
+| `soleri hooks demote <pack>`      | Step down action level                |
+| `soleri hooks add-pack <pack>`    | Install a hook pack                   |
+| `soleri hooks remove-pack <pack>` | Uninstall a hook pack                 |