@soleri/cli 9.7.2 → 9.8.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

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

package/src/commands/test.ts

@@ -1,8 +1,139 @@
 import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
+import { parse as parseYaml } from 'yaml';
+import { AgentYamlSchema } from '@soleri/forge/lib';
 import { detectAgent } from '../utils/agent-context.js';
 
+/**
+ * Run validation checks for a file-tree agent (no vitest needed).
+ * Returns the process exit code (0 = all passed, 1 = failures).
+ */
+function runFiletreeChecks(agentPath: string, _agentId: string): number {
+  let passed = 0;
+  let failed = 0;
+  const failures: string[] = [];
+
+  // ── 1. agent.yaml validation ───────────────────────
+  const yamlPath = join(agentPath, 'agent.yaml');
+  try {
+    const raw = readFileSync(yamlPath, 'utf-8');
+    const parsed = parseYaml(raw);
+    const result = AgentYamlSchema.safeParse(parsed);
+    if (result.success) {
+      p.log.success('agent.yaml — valid');
+      passed++;
+    } else {
+      const issues = result.error.issues
+        .map((i) => `  ${i.path.join('.')}: ${i.message}`)
+        .join('\n');
+      p.log.error(`agent.yaml — validation failed\n${issues}`);
+      failures.push('agent.yaml validation');
+      failed++;
+    }
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    p.log.error(`agent.yaml — could not read or parse: ${msg}`);
+    failures.push('agent.yaml read/parse');
+    failed++;
+  }
+
+  // ── 2. Skills syntax check ─────────────────────────
+  const skillsDir = join(agentPath, 'skills');
+  if (existsSync(skillsDir)) {
+    let validSkills = 0;
+    let invalidSkills = 0;
+    const invalidNames: string[] = [];
+
+    try {
+      const entries = readdirSync(skillsDir, { withFileTypes: true });
+      const skillDirs = entries.filter((e) => e.isDirectory());
+
+      for (const dir of skillDirs) {
+        const skillMd = join(skillsDir, dir.name, 'SKILL.md');
+        if (!existsSync(skillMd)) {
+          invalidSkills++;
+          invalidNames.push(`${dir.name}: missing SKILL.md`);
+          continue;
+        }
+
+        try {
+          const content = readFileSync(skillMd, 'utf-8');
+          const hasFrontmatter = content.startsWith('---');
+          const hasName = /^name:/m.test(content);
+          const hasDescription = /^description:/m.test(content);
+
+          if (hasFrontmatter && hasName && hasDescription) {
+            validSkills++;
+          } else {
+            invalidSkills++;
+            const missing: string[] = [];
+            if (!hasFrontmatter) missing.push('frontmatter (---)');
+            if (!hasName) missing.push('name:');
+            if (!hasDescription) missing.push('description:');
+            invalidNames.push(`${dir.name}: missing ${missing.join(', ')}`);
+          }
+        } catch {
+          invalidSkills++;
+          invalidNames.push(`${dir.name}: could not read SKILL.md`);
+        }
+      }
+
+      if (invalidSkills === 0) {
+        p.log.success(`skills — ${validSkills} valid, 0 invalid`);
+        passed++;
+      } else {
+        const details = invalidNames.map((n) => `  ${n}`).join('\n');
+        p.log.error(`skills — ${validSkills} valid, ${invalidSkills} invalid\n${details}`);
+        failures.push('skills syntax');
+        failed++;
+      }
+    } catch {
+      p.log.warn('skills — could not read skills/ directory');
+      // Not a failure — directory exists but unreadable is unusual, warn only
+    }
+  } else {
+    p.log.info('skills — no skills/ directory (skipped)');
+  }
+
+  // ── 3. Instructions check ──────────────────────────
+  const instructionsDir = join(agentPath, 'instructions');
+  if (existsSync(instructionsDir)) {
+    try {
+      const files = readdirSync(instructionsDir).filter((f) => f.endsWith('.md'));
+      if (files.length > 0) {
+        p.log.success(`instructions — ${files.length} .md file(s) found`);
+        passed++;
+      } else {
+        p.log.error('instructions — directory exists but contains no .md files');
+        failures.push('instructions empty');
+        failed++;
+      }
+    } catch {
+      p.log.error('instructions — could not read directory');
+      failures.push('instructions read');
+      failed++;
+    }
+  } else {
+    p.log.error('instructions — directory not found');
+    failures.push('instructions missing');
+    failed++;
+  }
+
+  // ── Summary ────────────────────────────────────────
+  if (failed === 0) {
+    p.log.success(`\n${passed} check(s) passed, 0 failed`);
+  } else {
+    p.log.error(
+      `\n${passed} check(s) passed, ${failed} failed:\n${failures.map((f) => `  - ${f}`).join('\n')}`,
+    );
+  }
+
+  return failed > 0 ? 1 : 0;
+}
+
 export function registerTest(program: Command): void {
   program
     .command('test')
@@ -17,6 +148,16 @@ export function registerTest(program: Command): void {
         process.exit(1);
       }
 
+      p.log.info(`Running tests for ${ctx.agentId}...`);
+
+      // ── File-tree agents: run validation checks (no vitest) ──
+      if (ctx.format === 'filetree') {
+        const code = runFiletreeChecks(ctx.agentPath, ctx.agentId);
+        process.exit(code);
+        return;
+      }
+
+      // ── TypeScript agents: spawn vitest as before ──
       const args: string[] = [];
       if (opts.watch) {
         // vitest (no "run") enables watch mode
@@ -30,8 +171,6 @@ export function registerTest(program: Command): void {
       const extra = cmd.args as string[];
       if (extra.length > 0) args.push(...extra);
 
-      p.log.info(`Running tests for ${ctx.agentId}...`);
-
       const child = spawn('npx', args, {
         cwd: ctx.agentPath,
         stdio: 'inherit',

package/src/hook-packs/flock-guard/manifest.json

@@ -32,5 +32,6 @@
       "timeout": 10,
       "statusMessage": "Releasing lockfile guard..."
     }
-  ]
+  ],
+  "scaffoldDefault": false
 }

package/src/hook-packs/marketing-research/manifest.json

@@ -20,5 +20,6 @@
       "statusMessage": "Checking marketing context..."
     }
   ],
-  "actionLevel": "remind"
+  "actionLevel": "remind",
+  "scaffoldDefault": false
 }

package/src/hook-packs/registry.ts

@@ -31,6 +31,8 @@ export interface HookPackManifest {
   lifecycleHooks?: HookPackLifecycleHook[];
   source?: 'built-in' | 'local';
   actionLevel?: 'remind' | 'warn' | 'block';
+  /** If false, pack is hidden from the scaffold picker but still installable via `hooks add-pack`. */
+  scaffoldDefault?: boolean;
 }
 
 const __filename = fileURLToPath(import.meta.url);