@soleri/cli 9.7.2 → 9.9.0

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

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from 'node:fs';
+import { accessSync, constants as fsConstants, readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
@@ -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);
@@ -80,13 +97,26 @@ export function registerCreate(program: Command): void {
               p.log.error(`Config file not found: ${configPath}`);
               process.exit(1);
             }
-            const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let raw: any;
+            try {
+              raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+            } catch {
+              p.log.error(
+                `Failed to parse ${configPath}. The file may be corrupted. Delete it and try again.`,
+              );
+              process.exit(1);
+            }
             const parsed = AgentConfigSchema.safeParse(raw);
             if (!parsed.success) {
               p.log.error(`Invalid config: ${parsed.error.message}`);
               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 +124,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);
@@ -151,6 +184,15 @@ export function registerCreate(program: Command): void {
             };
 
             const outputDir = opts?.dir ? resolve(opts.dir) : (config.outputDir ?? process.cwd());
+
+            // Preflight: check output directory is writable
+            try {
+              accessSync(outputDir, fsConstants.W_OK);
+            } catch {
+              p.log.error(`Cannot write to ${outputDir} — check permissions`);
+              process.exit(1);
+            }
+
             const nonInteractive = !!(opts?.yes || opts?.config);
 
             if (!nonInteractive) {
@@ -177,6 +219,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 +312,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/dev.ts

@@ -35,7 +35,14 @@ function runFileTreeDev(agentPath: string, agentId: string): void {
   regenerateClaudeMd(agentPath);
 
   // Start the engine server
-  const engineBin = require.resolve('@soleri/core/dist/engine/bin/soleri-engine.js');
+  let engineBin: string;
+  try {
+    engineBin = require.resolve('@soleri/core/dist/engine/bin/soleri-engine.js');
+  } catch {
+    p.log.error('Engine not found. Run: npm install @soleri/core');
+    process.exit(1);
+  }
+
   const engine = spawn('node', [engineBin, '--agent', join(agentPath, 'agent.yaml')], {
     stdio: ['pipe', 'inherit', 'inherit'],
     env: { ...process.env },
@@ -72,8 +79,11 @@ function runFileTreeDev(agentPath: string, agentId: string): void {
           regenerateClaudeMd(agentPath);
         }, 200);
       });
-    } catch {
-      // Directory may not exist yet — that's OK
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes('ENOENT')) {
+        p.log.warn(`File watch stopped: ${msg}. Restart soleri dev if changes stop updating.`);
+      }
     }
   }
 

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');