@soleri/cli 9.7.1 → 9.8.0

package/src/commands/add-pack.ts

@@ -1,170 +1,17 @@
-// @ts-nocheck — TODO: rewrite for v7 file-tree agents (uses removed @soleri/core APIs)
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
-import { execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { detectAgent } from '../utils/agent-context.js';
 
 export function registerAddPack(program: Command): void {
   program
     .command('add-pack')
-    .argument('<package>', 'npm package name (e.g., "@soleri/domain-design")')
-    .option('--no-install', 'Skip npm install (assume already installed)')
-    .option('--no-inject', 'Skip forge inject (CLAUDE.md, entry-point regeneration)')
-    .option('--force', 'Overwrite existing skills')
-    .description('Add a domain pack to the agent in the current directory')
-    .action(
-      async (packageName: string, opts: { install: boolean; inject: boolean; force: boolean }) => {
-        const ctx = detectAgent();
-        if (!ctx) {
-          p.log.error(
-            'No agent project detected in current directory. Run this from an agent root.',
-          );
-          process.exit(1);
-        }
-
-        const s = p.spinner();
-
-        // Step 1: npm install
-        if (opts.install) {
-          s.start(`Installing ${packageName}...`);
-          try {
-            execFileSync('npm', ['install', packageName], {
-              cwd: ctx.agentPath,
-              stdio: 'pipe',
-            });
-            s.stop(`Installed ${packageName}`);
-          } catch (err) {
-            s.stop('npm install failed');
-            p.log.error(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-          }
-        }
-
-        // Step 2: Validate it's a DomainPack
-        s.start('Validating domain pack...');
-        let pack;
-        try {
-          const { loadDomainPack } = await import('@soleri/core');
-          pack = await loadDomainPack(packageName);
-          s.stop(
-            `Validated: ${pack.name} v${pack.version} (${pack.ops.length} ops, ${pack.domains.length} domains${pack.facades?.length ? `, ${pack.facades.length} facades` : ''})`,
-          );
-        } catch (err) {
-          s.stop('Validation failed');
-          p.log.error(err instanceof Error ? err.message : String(err));
-          process.exit(1);
-        }
-
-        // Step 3: Update agent-config.json
-        s.start('Updating agent config...');
-        const configPath = join(ctx.agentPath, 'agent-config.json');
-        if (existsSync(configPath)) {
-          try {
-            const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-            if (!config.domainPacks) config.domainPacks = [];
-
-            const existing = config.domainPacks.find(
-              (ref: { package: string }) => ref.package === packageName,
-            );
-            if (existing) {
-              existing.version = pack.version;
-              s.stop('Updated existing pack reference in config');
-            } else {
-              config.domainPacks.push({
-                name: pack.name,
-                package: packageName,
-                version: pack.version,
-              });
-              s.stop('Added pack reference to config');
-            }
-
-            writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-          } catch (err) {
-            s.stop('Config update failed');
-            p.log.error(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-          }
-        } else {
-          s.stop('No agent-config.json found — skipped config update');
-        }
-
-        // Step 4: Install knowledge (tiered)
-        s.start('Installing knowledge...');
-        try {
-          const { installKnowledge, createAgentRuntime } = await import('@soleri/core');
-          const runtime = createAgentRuntime({
-            agentId: ctx.agentId,
-            vaultPath: join(ctx.agentPath, '.vault', 'vault.db'),
-          });
-          const resolvedDir = join(ctx.agentPath, 'node_modules', packageName);
-          const knowledgeResult = await installKnowledge(pack, runtime, resolvedDir);
-          runtime.close();
-          const total =
-            knowledgeResult.canonical + knowledgeResult.curated + knowledgeResult.captured;
-          s.stop(
-            total > 0
-              ? `Installed ${total} knowledge entries (${knowledgeResult.canonical} canonical, ${knowledgeResult.curated} curated, ${knowledgeResult.captured} captured)`
-              : 'No knowledge to install',
-          );
-        } catch (err) {
-          s.stop('Knowledge install skipped (non-fatal)');
-          p.log.warn(err instanceof Error ? err.message : String(err));
-        }
-
-        // Step 5: Install skills
-        s.start('Installing skills...');
-        try {
-          const { installSkills } = await import('@soleri/core');
-          const resolvedDir = join(ctx.agentPath, 'node_modules', packageName);
-          const skillsDir = join(ctx.agentPath, 'skills');
-          const skillsResult = installSkills(pack, skillsDir, resolvedDir, opts.force);
-          s.stop(
-            skillsResult.installed > 0
-              ? `Installed ${skillsResult.installed} skills (${skillsResult.skipped} skipped)`
-              : 'No skills to install',
-          );
-        } catch (err) {
-          s.stop('Skills install skipped (non-fatal)');
-          p.log.warn(err instanceof Error ? err.message : String(err));
-        }
-
-        // Step 6: Inject CLAUDE.md domain rules
-        if (pack.rules) {
-          s.start('Injecting CLAUDE.md domain rules...');
-          try {
-            const { injectDomainRules } = await import('@soleri/core');
-            const claudeMdPath = join(ctx.agentPath, 'CLAUDE.md');
-            injectDomainRules(claudeMdPath, pack.name, pack.rules);
-            s.stop('Injected domain rules into CLAUDE.md');
-          } catch (err) {
-            s.stop('CLAUDE.md injection skipped (non-fatal)');
-            p.log.warn(err instanceof Error ? err.message : String(err));
-          }
-        }
-
-        // Step 7: Run forge inject (regenerate entry-point, tests)
-        if (opts.inject) {
-          s.start('Regenerating agent code...');
-          try {
-            execFileSync('npx', ['soleri', 'agent', 'refresh'], {
-              cwd: ctx.agentPath,
-              stdio: 'pipe',
-            });
-            s.stop('Regenerated entry-point, tests, and CLAUDE.md');
-          } catch {
-            s.stop('Forge inject skipped — run `soleri agent refresh` manually');
-          }
-        }
-
-        // Summary
-        p.log.success(`\nDomain pack "${pack.name}" added to ${ctx.agentId}`);
-        p.log.info(`  Domains: ${pack.domains.join(', ')}`);
-        p.log.info(`  Ops: ${pack.ops.length} custom operations`);
-        if (pack.facades?.length) {
-          p.log.info(`  Facades: ${pack.facades.map((f) => f.name).join(', ')}`);
-        }
-      },
-    );
+    .argument('<pack>', 'Pack name')
+    .description('[DEPRECATED] Use "soleri pack install" or "soleri hooks add-pack" instead')
+    .action(async () => {
+      p.log.warn(
+        'The "add-pack" command is deprecated.\n\n' +
+          'Use these commands instead:\n' +
+          '  • soleri pack install <pack>    — install knowledge/domain packs\n' +
+          '  • soleri hooks add-pack <pack>  — install hook packs\n',
+      );
+    });
 }

package/src/commands/agent.ts

@@ -6,6 +6,7 @@
  */
 
 import { join, dirname } from 'node:path';
+import { createRequire } from 'node:module';
 import {
   existsSync,
   readFileSync,
@@ -20,6 +21,7 @@ import { homedir } from 'node:os';
 import { execFileSync } from 'node:child_process';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
+import { parse as parseYaml } from 'yaml';
 import { PackLockfile, checkNpmVersion, checkVersionCompat, SOLERI_HOME } from '@soleri/core';
 import {
   generateClaudeMdTemplate,
@@ -47,6 +49,75 @@ export function registerAgent(program: Command): void {
         return;
       }
 
+      if (ctx.format === 'filetree') {
+        // ─── File-tree agent (v7+) ─────────────────────────────
+        const yamlPath = join(ctx.agentPath, 'agent.yaml');
+        const yaml = parseYaml(readFileSync(yamlPath, 'utf-8'));
+        const agentName = yaml.name || yaml.id || 'unknown';
+        const agentId = yaml.id || 'unknown';
+        const domains: string[] = Array.isArray(yaml.domains) ? yaml.domains : [];
+
+        // Count skills (directories inside skills/)
+        const skillsDir = join(ctx.agentPath, 'skills');
+        let skillsCount = 0;
+        if (existsSync(skillsDir)) {
+          skillsCount = readdirSync(skillsDir, { withFileTypes: true }).filter((d) =>
+            d.isDirectory(),
+          ).length;
+        }
+
+        // Resolve engine version via require.resolve
+        let engineVersion = 'not installed';
+        try {
+          const req = createRequire(join(ctx.agentPath, 'package.json'));
+          const corePkgPath = req.resolve('@soleri/core/package.json');
+          engineVersion = JSON.parse(readFileSync(corePkgPath, 'utf-8')).version || 'unknown';
+        } catch {
+          engineVersion = 'not installed';
+        }
+
+        // Check for core update
+        const latestCore = checkNpmVersion('@soleri/core');
+
+        // Count vault entries if db exists
+        const dbPath = join(ctx.agentPath, 'data', 'vault.db');
+        const hasVault = existsSync(dbPath);
+
+        if (opts.json) {
+          console.log(
+            JSON.stringify(
+              {
+                agent: agentName,
+                id: agentId,
+                format: 'file-tree (v7)',
+                engine: engineVersion,
+                engineLatest: latestCore,
+                domains,
+                skills: skillsCount,
+                vault: { exists: hasVault },
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+
+        console.log(`\n  Agent: ${agentName}`);
+        console.log(`  ID: ${agentId}`);
+        console.log(`  Format: file-tree (v7)`);
+        console.log(
+          `  Engine: @soleri/core ${engineVersion}${latestCore && latestCore !== engineVersion ? ` (update available: ${latestCore})` : ''}`,
+        );
+        console.log(`  Domains: ${domains.length > 0 ? domains.join(', ') : 'none'}`);
+        console.log(`  Skills: ${skillsCount}`);
+        console.log(`\n  Vault: ${hasVault ? 'initialized' : 'not initialized'}`);
+        console.log('');
+        return;
+      }
+
+      // ─── Legacy TypeScript agent ──────────────────────────────
+
       // Read agent package.json
       const pkgPath = join(ctx.agentPath, 'package.json');
       const pkg = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, 'utf-8')) : {};
@@ -128,6 +199,96 @@ export function registerAgent(program: Command): void {
         return;
       }
 
+      // ─── File-tree agent (v7+) ────────────────────────────────
+      if (ctx.format === 'filetree') {
+        // Resolve installed @soleri/core version
+        let installedVersion: string | null = null;
+        try {
+          const req = createRequire(import.meta.url);
+          const corePkgPath = req.resolve('@soleri/core/package.json');
+          installedVersion = JSON.parse(readFileSync(corePkgPath, 'utf-8')).version ?? null;
+        } catch {
+          // @soleri/core not resolvable — will show as unknown
+        }
+
+        // Check latest version on npm
+        const latestCore = checkNpmVersion('@soleri/core');
+
+        if (opts.check) {
+          const installed = installedVersion ?? 'unknown';
+          const latest = latestCore ?? 'unknown';
+          if (installed === latest) {
+            console.log(`\n  Engine: @soleri/core ${installed} (up to date)`);
+          } else {
+            console.log(`\n  Engine: @soleri/core ${installed} → ${latest}`);
+          }
+          console.log(`  Format: file-tree (updates via template refresh)`);
+          console.log('');
+          return;
+        }
+
+        if (opts.dryRun) {
+          p.log.info('Would refresh templates (regenerate _engine.md, CLAUDE.md, sync skills)');
+          if (latestCore && installedVersion && latestCore !== installedVersion) {
+            p.log.info(
+              `Engine: ${installedVersion} → ${latestCore} (update @soleri/core globally to upgrade)`,
+            );
+          }
+          return;
+        }
+
+        // Run refresh: regenerate _engine.md, recompose CLAUDE.md, sync skills
+        const enginePath = join(ctx.agentPath, 'instructions', '_engine.md');
+        const claudeMdPath = join(ctx.agentPath, 'CLAUDE.md');
+
+        const skillFiles = generateSkills({ id: ctx.agentId } as AgentConfig);
+
+        // 1. Sync skills
+        if (skillFiles.length > 0) {
+          let newCount = 0;
+          let updatedCount = 0;
+          for (const [relPath, content] of skillFiles) {
+            const fullPath = join(ctx.agentPath, relPath);
+            const dirPath = dirname(fullPath);
+            const isNew = !existsSync(fullPath);
+            mkdirSync(dirPath, { recursive: true });
+            writeFileSync(fullPath, content, 'utf-8');
+            if (isNew) newCount++;
+            else updatedCount++;
+          }
+          p.log.success(
+            `Synced ${skillFiles.length} skills (${newCount} new, ${updatedCount} updated)`,
+          );
+        }
+
+        // 2. Regenerate _engine.md
+        mkdirSync(join(ctx.agentPath, 'instructions'), { recursive: true });
+        writeFileSync(enginePath, getEngineRulesContent(), 'utf-8');
+        p.log.success(`Regenerated ${enginePath}`);
+
+        // 3. Recompose CLAUDE.md
+        const result = composeClaudeMd(ctx.agentPath);
+        writeFileSync(claudeMdPath, result.content, 'utf-8');
+        p.log.success(
+          `Regenerated ${claudeMdPath} (${result.sources.length} sources, ${result.content.length} bytes)`,
+        );
+
+        // 4. Show engine version status
+        const installed = installedVersion ?? 'unknown';
+        const latest = latestCore ?? 'unknown';
+        if (installed !== 'unknown' && latest !== 'unknown' && installed !== latest) {
+          p.log.info(
+            `Engine: ${installed} → ${latest} (run \`npm update -g @soleri/cli\` to upgrade)`,
+          );
+        } else if (installed !== 'unknown') {
+          p.log.info(`Engine: @soleri/core ${installed} (up to date)`);
+        }
+
+        p.log.info('File-tree agents update by refreshing templates from the installed engine.');
+        return;
+      }
+
+      // ─── Legacy TypeScript agent ──────────────────────────────
       const pkgPath = join(ctx.agentPath, 'package.json');
       if (!existsSync(pkgPath)) {
         p.log.error('No package.json found in agent directory.');

package/src/commands/create.ts

@@ -10,9 +10,17 @@ import {
   type SetupTarget,
   scaffoldFileTree,
 } from '@soleri/forge/lib';
-import { runCreateWizard } from '../prompts/create-wizard.js';
+import { runCreateWizard, type WizardGitConfig } from '../prompts/create-wizard.js';
 import { listPacks } from '../hook-packs/registry.js';
 import { installPack } from '../hook-packs/installer.js';
+import {
+  isGitInstalled,
+  gitInit,
+  gitInitialCommit,
+  gitAddRemote,
+  gitPush,
+  ghCreateRepo,
+} from '../utils/git.js';
 
 function parseSetupTarget(value?: string): SetupTarget | undefined {
   if (!value) return undefined;
@@ -40,6 +48,7 @@ export function registerCreate(program: Command): void {
     .option('--dir <path>', `Parent directory for the agent (default: current directory)`)
     .option('--filetree', 'Create a file-tree agent (v7 — no TypeScript, no build step)')
     .option('--legacy', 'Create a legacy TypeScript agent (v6 — requires npm install + build)')
+    .option('--no-git', 'Skip git repository initialization (git init is on by default)')
     .description('Create a new Soleri agent')
     .action(
       async (
@@ -51,11 +60,15 @@ export function registerCreate(program: Command): void {
           setupTarget?: string;
           filetree?: boolean;
           legacy?: boolean;
+          git?: boolean;
         },
       ) => {
         try {
           let config;
 
+          let gitConfig: WizardGitConfig | undefined;
+          const skipGit = opts?.git === false; // Commander sets git=false when --no-git is passed
+
           if (name && opts?.yes && !opts?.config) {
             // Quick non-interactive: name + --yes = Italian Craftsperson defaults
             const id = name
@@ -73,6 +86,10 @@ export function registerCreate(program: Command): void {
               tone: 'mentor',
               greeting: `Ciao! I'm ${name}. Ready to build something beautiful today?`,
             });
+            // Non-interactive default: git init yes, no remote
+            if (!skipGit) {
+              gitConfig = { init: true };
+            }
           } else if (opts?.config) {
             // Non-interactive: read from config file
             const configPath = resolve(opts.config);
@@ -87,6 +104,10 @@ export function registerCreate(program: Command): void {
               process.exit(1);
             }
             config = parsed.data;
+            // Config path: default to git init unless --no-git or config specifies git
+            if (!skipGit) {
+              gitConfig = raw.git ?? { init: true };
+            }
           } else {
             // Interactive wizard
             const wizardResult = await runCreateWizard(name);
@@ -94,12 +115,15 @@ export function registerCreate(program: Command): void {
               p.outro('Cancelled.');
               return;
             }
-            const parsed = AgentConfigSchema.safeParse(wizardResult);
+            const parsed = AgentConfigSchema.safeParse(wizardResult.config);
             if (!parsed.success) {
               p.log.error(`Invalid config: ${parsed.error.message}`);
               process.exit(1);
             }
             config = parsed.data;
+            if (!skipGit) {
+              gitConfig = wizardResult.git;
+            }
           }
 
           const setupTarget = parseSetupTarget(opts?.setupTarget);
@@ -177,6 +201,68 @@ export function registerCreate(program: Command): void {
               process.exit(1);
             }
 
+            // ─── Git initialization ──────────────────────────────
+            if (gitConfig?.init) {
+              const hasGit = await isGitInstalled();
+              if (!hasGit) {
+                p.log.warn(
+                  'git is not installed — skipping repository initialization. Install git from https://git-scm.com/',
+                );
+              } else {
+                const agentDir = result.agentDir;
+                s.start('Initializing git repository...');
+
+                const initResult = await gitInit(agentDir);
+                if (!initResult.ok) {
+                  s.stop('git init failed');
+                  p.log.warn(`git init failed: ${initResult.error}`);
+                } else {
+                  const commitResult = await gitInitialCommit(
+                    agentDir,
+                    `feat: scaffold agent "${config.name}"`,
+                  );
+                  if (!commitResult.ok) {
+                    s.stop('Initial commit failed');
+                    p.log.warn(`Initial commit failed: ${commitResult.error}`);
+                  } else {
+                    s.stop('Git repository initialized with initial commit');
+                  }
+
+                  // Remote setup
+                  if (gitConfig.remote && initResult.ok && commitResult.ok) {
+                    if (gitConfig.remote.type === 'gh') {
+                      s.start('Creating GitHub repository...');
+                      const ghResult = await ghCreateRepo(config.id, {
+                        visibility: gitConfig.remote.visibility ?? 'private',
+                        dir: agentDir,
+                      });
+                      if (!ghResult.ok) {
+                        s.stop('GitHub repo creation failed');
+                        p.log.warn(`gh repo create failed: ${ghResult.error}`);
+                      } else {
+                        s.stop(`Pushed to ${ghResult.url ?? 'GitHub'}`);
+                      }
+                    } else if (gitConfig.remote.type === 'manual' && gitConfig.remote.url) {
+                      s.start('Setting up remote...');
+                      const remoteResult = await gitAddRemote(agentDir, gitConfig.remote.url);
+                      if (!remoteResult.ok) {
+                        s.stop('Failed to add remote');
+                        p.log.warn(`git remote add failed: ${remoteResult.error}`);
+                      } else {
+                        const pushResult = await gitPush(agentDir);
+                        if (!pushResult.ok) {
+                          s.stop('Push failed');
+                          p.log.warn(`git push failed: ${pushResult.error}`);
+                        } else {
+                          s.stop('Pushed to remote');
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+
             p.note(result.summary, 'Next steps');
             p.outro('Done!');
             return;
@@ -208,7 +294,7 @@ export function registerCreate(program: Command): void {
               selectedPacks = selectedPacks.filter((pk) => available.includes(pk));
             }
           } else if (!nonInteractive && claudeSetup) {
-            const packs = listPacks();
+            const packs = listPacks().filter((pk) => pk.scaffoldDefault !== false);
             const packChoices = packs.map((pk) => ({
               value: pk.name,
               label: pk.name,

package/src/commands/doctor.ts

@@ -15,6 +15,7 @@ export function registerDoctor(program: Command): void {
 
       for (const r of results) {
         if (r.status === 'pass') log.pass(r.label, r.detail);
+        else if (r.status === 'skip') log.skip(r.label, r.detail);
         else if (r.status === 'warn') {
           log.warn(r.label, r.detail);
           hasWarnings = true;

package/src/commands/extend.ts

@@ -2,7 +2,22 @@ import type { Command } from 'commander';
 import * as p from '@clack/prompts';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { detectAgent } from '../utils/agent-context.js';
+import { detectAgent, type AgentContext } from '../utils/agent-context.js';
+
+function warnFiletreeAndExit(ctx: AgentContext): boolean {
+  if (ctx.format !== 'filetree') return false;
+  p.log.warn(
+    [
+      `The 'extend' command requires a TypeScript agent format.`,
+      '',
+      'For file-tree agents, use these alternatives:',
+      '  • Custom skills: add SKILL.md files to skills/{name}/SKILL.md',
+      '  • Hook packs: soleri hooks add-pack <pack>',
+      '  • Custom knowledge: add JSON files to knowledge/',
+    ].join('\n'),
+  );
+  process.exit(0);
+}
 
 export function registerExtend(program: Command): void {
   const extend = program
@@ -18,6 +33,7 @@ export function registerExtend(program: Command): void {
         p.log.error('No agent project detected. Run this from an agent root.');
         process.exit(1);
       }
+      warnFiletreeAndExit(ctx);
 
       const extDir = join(ctx.agentPath, 'src', 'extensions');
       if (existsSync(join(extDir, 'index.ts'))) {
@@ -53,6 +69,7 @@ export function registerExtend(program: Command): void {
         p.log.error('No agent project detected. Run this from an agent root.');
         process.exit(1);
       }
+      warnFiletreeAndExit(ctx);
 
       const opsDir = join(ctx.agentPath, 'src', 'extensions', 'ops');
       mkdirSync(opsDir, { recursive: true });
@@ -108,6 +125,7 @@ export function ${fnName}(runtime: AgentRuntime): OpDefinition {
         p.log.error('No agent project detected. Run this from an agent root.');
         process.exit(1);
       }
+      warnFiletreeAndExit(ctx);
 
       const facadesDir = join(ctx.agentPath, 'src', 'extensions', 'facades');
       mkdirSync(facadesDir, { recursive: true });
@@ -162,6 +180,7 @@ export function create${className}Facade(runtime: AgentRuntime): FacadeConfig {
         p.log.error('No agent project detected. Run this from an agent root.');
         process.exit(1);
       }
+      warnFiletreeAndExit(ctx);
 
       const mwDir = join(ctx.agentPath, 'src', 'extensions', 'middleware');
       mkdirSync(mwDir, { recursive: true });

package/src/commands/install-knowledge.ts

@@ -98,6 +98,7 @@ export function registerInstallKnowledge(program: Command): void {
           agentPath: ctx.agentPath,
           bundlePath,
           generateFacades: opts.facades,
+          format: ctx.format,
         });
 
         s.stop(result.success ? result.summary : 'Installation failed');