@soleri/cli 9.15.0 → 9.16.7

package/src/commands/knowledge.ts

@@ -0,0 +1,124 @@
+/**
+ * Knowledge CLI — export vault entries as portable knowledge bundle JSON files.
+ *
+ * `soleri knowledge export --domain <name>`  — export single domain to knowledge/<name>/patterns.json
+ * `soleri knowledge export --all`            — export all domains
+ * `soleri knowledge export --min-score 0.5`  — filter low-quality entries
+ */
+
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import type { Command } from 'commander';
+import * as log from '../utils/logger.js';
+import { detectAgent } from '../utils/agent-context.js';
+import { resolveVaultDbPath } from '../utils/vault-db.js';
+
+interface ExportOpts {
+  domain?: string;
+  all?: boolean;
+  minScore?: string;
+  output?: string;
+}
+
+export function registerKnowledge(program: Command): void {
+  const knowledge = program.command('knowledge').description('Knowledge bundle management');
+
+  knowledge
+    .command('export')
+    .description('Export vault entries to portable knowledge bundle JSON files')
+    .option('--domain <name>', 'Export a specific domain')
+    .option('--all', 'Export all domains')
+    .option('--min-score <number>', 'Minimum quality score threshold (0-1)', '0')
+    .option('--output <dir>', 'Output directory (default: ./knowledge/)')
+    .action(async (opts: ExportOpts) => {
+      const agent = detectAgent();
+      if (!agent) {
+        log.fail('Not in a Soleri agent project', 'Run from an agent directory');
+        process.exit(1);
+      }
+
+      if (!opts.domain && !opts.all) {
+        log.fail('Specify --domain <name> or --all');
+        process.exit(1);
+      }
+
+      const vaultDbPath = resolveVaultDbPath(agent.agentId);
+      if (!vaultDbPath) {
+        log.fail('Vault DB not found', 'Run the agent once to initialize its vault database.');
+        process.exit(1);
+      }
+
+      const minScore = parseFloat(opts.minScore ?? '0');
+      const outputDir = opts.output ? resolve(opts.output) : resolve('knowledge');
+
+      const { Vault } = await import('@soleri/core');
+      const vault = new Vault(vaultDbPath);
+
+      try {
+        log.heading('Knowledge Export');
+
+        const domainsToExport: string[] = [];
+
+        if (opts.all) {
+          const all = vault.list({ limit: 50_000 });
+          const domainSet = new Set<string>();
+          for (const e of all) {
+            if (e.domain) domainSet.add(e.domain);
+          }
+          domainsToExport.push(...domainSet);
+        } else if (opts.domain) {
+          domainsToExport.push(opts.domain);
+        }
+
+        if (domainsToExport.length === 0) {
+          log.warn('No domains found in vault');
+          return;
+        }
+
+        let totalExported = 0;
+
+        for (const domain of domainsToExport) {
+          const entries = vault.list({ domain, limit: 10_000 });
+
+          // Filter by score if provided (vault entries may have a score/severity field)
+          const filtered = entries.filter((e) => {
+            if (minScore <= 0) return true;
+            // Use tags count as a rough quality proxy when no explicit score exists
+            const tagScore = (e.tags?.length ?? 0) / 10 + (e.description ? 0.5 : 0);
+            return tagScore >= minScore;
+          });
+
+          if (filtered.length === 0) {
+            log.warn(`Domain "${domain}": no entries passed min-score filter`);
+            continue;
+          }
+
+          // Format entries into knowledge bundle schema
+          const bundleEntries = filtered.map((e) => ({
+            id: e.id,
+            type: e.type,
+            domain: e.domain,
+            title: e.title,
+            description: e.description,
+            ...(e.severity ? { severity: e.severity } : {}),
+            ...(e.tags?.length ? { tags: e.tags } : {}),
+          }));
+
+          const domainDir = join(outputDir, domain);
+          mkdirSync(domainDir, { recursive: true });
+          const outPath = join(domainDir, 'patterns.json');
+          writeFileSync(outPath, JSON.stringify(bundleEntries, null, 2) + '\n', 'utf-8');
+
+          log.pass(`${domain}: exported ${filtered.length} entries`, outPath);
+          totalExported += filtered.length;
+        }
+
+        log.pass(
+          `Total: ${totalExported} entries across ${domainsToExport.length} domain(s)`,
+          outputDir,
+        );
+      } finally {
+        vault.close();
+      }
+    });
+}

package/src/commands/pack.ts

@@ -8,7 +8,7 @@
  */
 
 import { join, resolve as pathResolve } from 'node:path';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
 import {
@@ -17,8 +17,14 @@ import {
   resolvePack,
   checkNpmVersion,
   getBuiltinKnowledgePacksDirs,
+  LLMClient,
+  KeyPool,
+  loadKeyPoolConfig,
+  Vault,
+  SOLERI_HOME,
 } from '@soleri/core';
 import type { LockEntry, PackSource } from '@soleri/core';
+import { resolveVaultDbPath } from '../utils/vault-db.js';
 
 // ─── Tier display helpers ────────────────────────────────────────────
 
@@ -774,10 +780,222 @@ export function registerPack(program: Command): void {
         process.exit(1);
       }
     });
+
+  // ─── Seed ─────────────────────────────────────────────────────────────
+  pack
+    .command('seed')
+    .argument('<domain>', 'Domain to generate knowledge entries for (e.g. typescript, react)')
+    .option('--entries <count>', 'Number of entries to generate', '15')
+    .option('--dry-run', 'Preview generated entries without seeding vault')
+    .option('--output <path>', 'Save entries as pack files instead of seeding vault')
+    .option('--yes', 'Skip confirmation prompt')
+    .description('Generate domain knowledge entries using LLM and seed them into the vault')
+    .action(
+      async (
+        domain: string,
+        opts: { entries?: string; dryRun?: boolean; output?: string; yes?: boolean },
+      ) => {
+        const ctx = detectAgent();
+        if (!ctx) {
+          p.log.error('No agent project detected in current directory.');
+          process.exit(1);
+        }
+
+        const entryCount = Math.min(Math.max(parseInt(opts.entries ?? '15', 10) || 15, 5), 30);
+
+        // ─── LLM client setup ──────────────────────────────────────
+        const keyConfig = loadKeyPoolConfig(ctx.agentId);
+        const openaiPool = new KeyPool(keyConfig.openai);
+        const anthropicPool = new KeyPool(keyConfig.anthropic);
+        const llm = new LLMClient(openaiPool, anthropicPool, ctx.agentId);
+        const available = llm.isAvailable();
+
+        if (!available.openai && !available.anthropic) {
+          p.log.error(
+            'No LLM API key configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY, ' +
+              `or add keys to ${join(SOLERI_HOME, ctx.agentId, 'keys.json')}.`,
+          );
+          process.exit(1);
+        }
+
+        // ─── Generate entries ──────────────────────────────────────
+        const s = p.spinner();
+        s.start(`Generating ${entryCount} knowledge entries for domain "${domain}"...`);
+
+        const provider = available.anthropic ? 'anthropic' : 'openai';
+        const model = available.anthropic ? 'claude-haiku-4-5-20251001' : 'gpt-4o-mini';
+
+        const systemPrompt = `You are a knowledge engineering expert. Generate structured knowledge entries for developer vaults.
+Each entry must be valid JSON matching this schema:
+{
+  "id": "string (kebab-case, domain-prefixed, unique)",
+  "type": "pattern" | "anti-pattern" | "rule" | "playbook",
+  "domain": "string",
+  "title": "string (concise, searchable)",
+  "severity": "critical" | "warning" | "suggestion",
+  "description": "string (2-3 sentences, actionable)",
+  "why": "string (1-2 sentences explaining the reasoning)",
+  "tags": ["array", "of", "keywords"],
+  "context": "string (optional — when this applies)"
+}
+
+Return ONLY a JSON array of entries, no prose, no markdown fences.`;
+
+        const userPrompt = `Generate exactly ${entryCount} high-quality knowledge vault entries for the "${domain}" domain.
+Focus on: patterns that prevent bugs, common anti-patterns, best practices, and rules experienced developers follow.
+Make entries concrete and actionable — not generic platitudes.
+Return a JSON array of ${entryCount} entries.`;
+
+        let generatedEntries: SeedEntry[] = [];
+
+        try {
+          const result = await llm.complete({
+            caller: 'pack-seed',
+            systemPrompt,
+            userPrompt,
+            provider,
+            model,
+            maxTokens: 8000,
+            temperature: 0.4,
+          });
+
+          s.stop('Generation complete');
+
+          // Parse JSON from response
+          const text = result.text.trim();
+          const jsonStart = text.indexOf('[');
+          const jsonEnd = text.lastIndexOf(']');
+          if (jsonStart === -1 || jsonEnd === -1) {
+            p.log.error('LLM did not return a valid JSON array');
+            process.exit(1);
+          }
+
+          const parsed = JSON.parse(text.slice(jsonStart, jsonEnd + 1)) as unknown[];
+          generatedEntries = parsed
+            .filter(
+              (e): e is SeedEntry =>
+                typeof e === 'object' &&
+                e !== null &&
+                'id' in e &&
+                'title' in e &&
+                'description' in e,
+            )
+            .map((e) => ({
+              ...e,
+              domain: domain,
+              tags: Array.isArray(e.tags) ? e.tags : [],
+            }));
+        } catch (err) {
+          s.stop('Generation failed');
+          p.log.error(err instanceof Error ? err.message : String(err));
+          process.exit(1);
+        }
+
+        if (generatedEntries.length === 0) {
+          p.log.error('No valid entries generated.');
+          process.exit(1);
+        }
+
+        // ─── Dedup check ───────────────────────────────────────────
+        const vaultDbPath = resolveVaultDbPath(ctx.agentId);
+        let dedupedEntries = generatedEntries;
+
+        if (vaultDbPath) {
+          const vault = new Vault(vaultDbPath);
+          const existing = new Set(vault.list({ domain, limit: 1000 }).map((e) => e.id));
+          vault.close();
+          const before = dedupedEntries.length;
+          dedupedEntries = dedupedEntries.filter((e) => !existing.has(e.id));
+          const skipped = before - dedupedEntries.length;
+          if (skipped > 0) {
+            p.log.info(`Skipped ${skipped} duplicate entries (already in vault)`);
+          }
+        }
+
+        if (dedupedEntries.length === 0) {
+          p.log.success(`All generated entries already exist in vault for domain "${domain}".`);
+          return;
+        }
+
+        // ─── Preview table ─────────────────────────────────────────
+        console.log('');
+        console.log(`  Generated ${dedupedEntries.length} entries for "${domain}":`);
+        console.log('');
+        const idWidth = Math.max(2, ...dedupedEntries.map((e) => e.id.length));
+        const titleWidth = Math.max(5, ...dedupedEntries.map((e) => e.title.length));
+        console.log(
+          `  ${'ID'.padEnd(idWidth)}  ${'Title'.padEnd(titleWidth)}  Type         Severity`,
+        );
+        console.log(`  ${'-'.repeat(idWidth)}  ${'-'.repeat(titleWidth)}  -----------  --------`);
+        for (const entry of dedupedEntries) {
+          console.log(
+            `  ${entry.id.padEnd(idWidth)}  ${entry.title.padEnd(titleWidth)}  ${(entry.type ?? 'pattern').padEnd(11)}  ${entry.severity ?? 'suggestion'}`,
+          );
+        }
+        console.log('');
+
+        if (opts.dryRun) {
+          p.log.info(`Dry run — ${dedupedEntries.length} entries generated, vault not modified.`);
+          return;
+        }
+
+        // ─── Output to files ───────────────────────────────────────
+        if (opts.output) {
+          const outDir = pathResolve(opts.output);
+          mkdirSync(outDir, { recursive: true });
+          const outPath = join(outDir, `${domain}.json`);
+          writeFileSync(outPath, JSON.stringify({ domain, entries: dedupedEntries }, null, 2));
+          p.log.success(`Saved ${dedupedEntries.length} entries to ${outPath}`);
+          return;
+        }
+
+        // ─── Confirm + seed vault ──────────────────────────────────
+        if (!opts.yes) {
+          const confirm = await p.confirm({
+            message: `Seed ${dedupedEntries.length} entries into vault for domain "${domain}"?`,
+          });
+          if (p.isCancel(confirm) || !confirm) {
+            p.log.info('Cancelled — vault not modified.');
+            return;
+          }
+        }
+
+        if (!vaultDbPath) {
+          p.log.error('Vault not initialized. Run `soleri install` first.');
+          process.exit(1);
+        }
+
+        const vault = new Vault(vaultDbPath);
+        const seeded = vault.seed(
+          dedupedEntries.map((e) => ({
+            ...e,
+            id: e.id,
+            type: (e.type ?? 'pattern') as 'pattern' | 'anti-pattern' | 'rule' | 'playbook',
+            severity: (e.severity ?? 'suggestion') as 'critical' | 'warning' | 'suggestion',
+            tags: e.tags ?? [],
+          })),
+        );
+        vault.close();
+
+        p.log.success(`Seeded ${seeded} knowledge entries for domain "${domain}" into vault.`);
+      },
+    );
 }
 
 // ─── Helpers ──────────────────────────────────────────────────────────
 
+interface SeedEntry {
+  id: string;
+  type?: string;
+  domain: string;
+  title: string;
+  severity?: string;
+  description: string;
+  why?: string;
+  tags: string[];
+  context?: string;
+}
+
 function listMdFiles(dir: string): string[] {
   try {
     const { basename } = require('node:path');

package/src/commands/schedule.ts

@@ -0,0 +1,150 @@
+/**
+ * Schedule CLI — manage autonomous scheduled agent tasks.
+ *
+ * `soleri schedule create --name X --cron "0 2 * * *" --prompt "run dream"`
+ * `soleri schedule list`
+ * `soleri schedule delete --id <id>`
+ * `soleri schedule pause --id <id>`
+ * `soleri schedule resume --id <id>`
+ */
+
+import type { Command } from 'commander';
+import * as p from '@clack/prompts';
+import { detectAgent } from '../utils/agent-context.js';
+import * as log from '../utils/logger.js';
+
+export function registerSchedule(program: Command): void {
+  const schedule = program
+    .command('schedule')
+    .description('Manage autonomous scheduled agent tasks');
+
+  // ─── create ────────────────────────────────────────────────────────
+  schedule
+    .command('create')
+    .description('Create a new scheduled task')
+    .requiredOption('--name <name>', 'Task name (unique per agent)')
+    .requiredOption('--cron <expr>', 'Cron expression (5-field, min 1-hour interval)')
+    .requiredOption('--prompt <text>', 'Prompt passed to claude -p when task fires')
+    .option('--project-dir <path>', 'Agent project directory (default: current directory)')
+    .action(async (opts: { name: string; cron: string; prompt: string; projectDir?: string }) => {
+      const agent = detectAgent();
+      if (!agent) {
+        log.fail('Not in a Soleri agent project', 'Run from an agent directory');
+        process.exit(1);
+      }
+
+      const { Scheduler, InMemorySchedulerStore, validateCron } = await import('@soleri/core');
+
+      const cronError = validateCron(opts.cron);
+      if (cronError) {
+        log.fail('Invalid cron expression', cronError);
+        process.exit(1);
+      }
+
+      const s = p.spinner();
+      s.start('Creating scheduled task...');
+
+      try {
+        const scheduler = new Scheduler(undefined, new InMemorySchedulerStore());
+        const result = await scheduler.create({
+          name: opts.name,
+          cronExpression: opts.cron,
+          prompt: opts.prompt,
+          projectPath: opts.projectDir ?? agent.agentPath,
+        });
+
+        if ('error' in result) {
+          s.stop('Failed');
+          log.fail(result.error);
+          process.exit(1);
+        }
+
+        s.stop('Task created');
+        log.pass(`Task "${opts.name}" scheduled`, `ID: ${result.id}`);
+        p.log.info(`Cron: ${opts.cron}`);
+        p.log.info(`Platform ID: ${result.platformId ?? 'pending'}`);
+      } catch (err) {
+        s.stop('Failed');
+        log.fail(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  // ─── list ──────────────────────────────────────────────────────────
+  schedule
+    .command('list')
+    .description('List all scheduled tasks')
+    .action(async () => {
+      const { Scheduler, InMemorySchedulerStore } = await import('@soleri/core');
+      const scheduler = new Scheduler(undefined, new InMemorySchedulerStore());
+      const tasks = await scheduler.list();
+
+      if (tasks.length === 0) {
+        p.log.info('No scheduled tasks. Use: soleri schedule create');
+        return;
+      }
+
+      log.heading(`Scheduled Tasks (${tasks.length})`);
+      for (const t of tasks) {
+        const status = t.enabled ? 'enabled' : 'paused';
+        const sync = t.platformSynced ? 'synced' : 'not synced';
+        p.log.info(`${t.name}  [${status}] [${sync}]`);
+        p.log.info(`  ID: ${t.id}  Cron: ${t.cronExpression}`);
+        p.log.info(`  Prompt: ${t.prompt.slice(0, 60)}${t.prompt.length > 60 ? '...' : ''}`);
+      }
+    });
+
+  // ─── delete ────────────────────────────────────────────────────────
+  schedule
+    .command('delete')
+    .description('Delete a scheduled task')
+    .requiredOption('--id <id>', 'Task ID to delete')
+    .action(async (opts: { id: string }) => {
+      const { Scheduler, InMemorySchedulerStore } = await import('@soleri/core');
+      const scheduler = new Scheduler(undefined, new InMemorySchedulerStore());
+      const result = await scheduler.delete(opts.id);
+
+      if (!result.deleted) {
+        log.fail(result.error ?? 'Delete failed');
+        process.exit(1);
+      }
+
+      log.pass(`Task ${opts.id} deleted`);
+    });
+
+  // ─── pause ─────────────────────────────────────────────────────────
+  schedule
+    .command('pause')
+    .description('Pause a scheduled task without deleting it')
+    .requiredOption('--id <id>', 'Task ID to pause')
+    .action(async (opts: { id: string }) => {
+      const { Scheduler, InMemorySchedulerStore } = await import('@soleri/core');
+      const scheduler = new Scheduler(undefined, new InMemorySchedulerStore());
+      const result = await scheduler.pause(opts.id);
+
+      if (!result.paused) {
+        log.fail(result.error ?? 'Pause failed');
+        process.exit(1);
+      }
+
+      log.pass(`Task ${opts.id} paused`);
+    });
+
+  // ─── resume ────────────────────────────────────────────────────────
+  schedule
+    .command('resume')
+    .description('Resume a paused scheduled task')
+    .requiredOption('--id <id>', 'Task ID to resume')
+    .action(async (opts: { id: string }) => {
+      const { Scheduler, InMemorySchedulerStore } = await import('@soleri/core');
+      const scheduler = new Scheduler(undefined, new InMemorySchedulerStore());
+      const result = await scheduler.resume(opts.id);
+
+      if (!result.resumed) {
+        log.fail(result.error ?? 'Resume failed');
+        process.exit(1);
+      }
+
+      log.pass(`Task ${opts.id} resumed`);
+    });
+}

package/src/commands/staging.ts

@@ -4,12 +4,12 @@ import { join, relative } from 'node:path';
 import { homedir } from 'node:os';
 import * as log from '../utils/logger.js';
 
-export const STAGING_ROOT = join(homedir(), '.soleri', 'staging');
+const STAGING_ROOT = join(homedir(), '.soleri', 'staging');
 
 /** Default max age for stale staging entries (7 days). */
 const DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
-export interface StagedEntry {
+interface StagedEntry {
   id: string;
   timestamp: string;
   path: string;
@@ -20,7 +20,7 @@ export interface StagedEntry {
 /**
  * Walk a directory tree and collect all items with their relative paths.
  */
-export function walkDir(dir: string, base: string): { relPath: string; size: number }[] {
+function walkDir(dir: string, base: string): { relPath: string; size: number }[] {
   const results: { relPath: string; size: number }[] = [];
   if (!existsSync(dir)) return results;
 
@@ -41,7 +41,7 @@ export function walkDir(dir: string, base: string): { relPath: string; size: num
 /**
  * List all staged entries.
  */
-export function listStaged(): StagedEntry[] {
+function listStaged(): StagedEntry[] {
   if (!existsSync(STAGING_ROOT)) return [];
 
   const entries: StagedEntry[] = [];
@@ -69,7 +69,7 @@ export function listStaged(): StagedEntry[] {
 /**
  * Parse a duration string like "7d", "24h", "30m" into milliseconds.
  */
-export function parseDuration(duration: string): number | null {
+function parseDuration(duration: string): number | null {
   const match = duration.match(/^(\d+)(d|h|m)$/);
   if (!match) return null;
 

package/src/main.ts

@@ -35,6 +35,9 @@ import { registerDream } from './commands/dream.js';
 import { registerUpdate } from './commands/update.js';
 import { registerBrain } from './commands/brain.js';
 import { registerValidateSkills } from './commands/validate-skills.js';
+import { registerKnowledge } from './commands/knowledge.js';
+import { registerSchedule } from './commands/schedule.js';
+import { registerChat } from './commands/chat.js';
 
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
@@ -102,4 +105,7 @@ registerDream(program);
 registerUpdate(program);
 registerBrain(program);
 registerValidateSkills(program);
+registerKnowledge(program);
+registerSchedule(program);
+registerChat(program);
 program.parse();