@soleri/cli 9.7.1 → 9.8.0

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/installer.ts

@@ -87,10 +87,16 @@ function resolveLifecycleHooks(
   return hooks;
 }
 
-interface SettingsHookEntry {
+interface SettingsHookDef {
   type: 'command';
   command: string;
   timeout?: number;
+  statusMessage?: string;
+}
+
+interface SettingsHookEntry {
+  matcher?: string;
+  hooks: SettingsHookDef[];
   [key: string]: unknown;
 }
 
@@ -121,17 +127,24 @@ function addLifecycleHooks(
     const eventKey = hook.event;
     const eventHooks = (hooks[eventKey] ?? []) as SettingsHookEntry[];
     const alreadyExists = eventHooks.some(
-      (h) => h.command === hook.command && h[PACK_MARKER] === sourcePack,
+      (h) => h[PACK_MARKER] === sourcePack && h.hooks?.some((hd) => hd.command === hook.command),
     );
     if (!alreadyExists) {
-      const entry: SettingsHookEntry = {
+      const hookDef: SettingsHookDef = {
         type: hook.type,
         command: hook.command,
-        [PACK_MARKER]: sourcePack,
       };
       if (hook.timeout) {
-        entry.timeout = hook.timeout;
+        hookDef.timeout = hook.timeout;
+      }
+      if (hook.statusMessage) {
+        hookDef.statusMessage = hook.statusMessage;
       }
+      const entry: SettingsHookEntry = {
+        matcher: hook.matcher || '',
+        hooks: [hookDef],
+        [PACK_MARKER]: sourcePack,
+      };
       eventHooks.push(entry);
       hooks[eventKey] = eventHooks;
       added.push(`${eventKey}:${hook.matcher}`);
@@ -144,7 +157,10 @@ function addLifecycleHooks(
 
 function removeLifecycleHooks(claudeDir: string, packName: string): string[] {
   const settings = readClaudeSettings(claudeDir);
-  const hooks = (settings['hooks'] ?? {}) as Record<string, SettingsHookEntry[]>;
+  const hooks = (settings['hooks'] ?? {}) as Record<
+    string,
+    (SettingsHookEntry | Record<string, unknown>)[]
+  >;
   const removed: string[] = [];
   for (const [eventKey, eventHooks] of Object.entries(hooks)) {
     if (!Array.isArray(eventHooks)) continue;
@@ -301,7 +317,10 @@ export function isPackInstalled(
         const eventHooks = hooksObj[hook.event];
         if (
           Array.isArray(eventHooks) &&
-          eventHooks.some((h) => h.command === hook.command && h[PACK_MARKER] === sourcePack)
+          eventHooks.some(
+            (h) =>
+              h[PACK_MARKER] === sourcePack && h.hooks?.some((hd) => hd.command === hook.command),
+          )
         ) {
           present++;
         }

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

package/src/prompts/create-wizard.ts

@@ -8,6 +8,23 @@
 import * as p from '@clack/prompts';
 import type { AgentConfigInput } from '@soleri/forge/lib';
 import { ITALIAN_CRAFTSPERSON } from '@soleri/core/personas';
+import { isGhInstalled } from '../utils/git.js';
+
+/** Git configuration collected from the wizard. */
+export interface WizardGitConfig {
+  init: boolean;
+  remote?: {
+    type: 'gh' | 'manual';
+    url?: string;
+    visibility?: 'public' | 'private';
+  };
+}
+
+/** Full result from the create wizard. */
+export interface CreateWizardResult {
+  config: AgentConfigInput;
+  git: WizardGitConfig;
+}
 
 /** Slugify a display name into a kebab-case ID. */
 function slugify(name: string): string {
@@ -19,9 +36,9 @@ function slugify(name: string): string {
 
 /**
  * Run the simplified create wizard.
- * Returns an AgentConfigInput or null if cancelled.
+ * Returns a CreateWizardResult or null if cancelled.
  */
-export async function runCreateWizard(initialName?: string): Promise<AgentConfigInput | null> {
+export async function runCreateWizard(initialName?: string): Promise<CreateWizardResult | null> {
   p.intro('Create a new Soleri agent');
 
   // ─── Step 1: Name ───────────────────────────────────────────
@@ -119,17 +136,95 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
 
   if (p.isCancel(confirm) || !confirm) return null;
 
+  // ─── Step 3: Git setup ──────────────────────────────────────
+  const gitInit = await p.confirm({
+    message: 'Initialize as a git repository?',
+    initialValue: true,
+  });
+
+  if (p.isCancel(gitInit)) return null;
+
+  const git: WizardGitConfig = { init: gitInit as boolean };
+
+  if (git.init) {
+    const pushRemote = await p.confirm({
+      message: 'Push to a remote repository?',
+      initialValue: false,
+    });
+
+    if (p.isCancel(pushRemote)) return null;
+
+    if (pushRemote) {
+      const ghAvailable = await isGhInstalled();
+
+      let remoteType: 'gh' | 'manual';
+
+      if (ghAvailable) {
+        const remoteChoice = await p.select({
+          message: 'How would you like to set up the remote?',
+          options: [
+            { value: 'gh' as const, label: 'Create a new GitHub repository' },
+            { value: 'manual' as const, label: 'Add an existing remote URL' },
+          ],
+        });
+
+        if (p.isCancel(remoteChoice)) return null;
+        remoteType = remoteChoice as 'gh' | 'manual';
+      } else {
+        remoteType = 'manual';
+      }
+
+      if (remoteType === 'gh') {
+        const visibility = await p.select({
+          message: 'Repository visibility?',
+          options: [
+            { value: 'private' as const, label: 'Private' },
+            { value: 'public' as const, label: 'Public' },
+          ],
+          initialValue: 'private' as const,
+        });
+
+        if (p.isCancel(visibility)) return null;
+
+        git.remote = {
+          type: 'gh',
+          visibility: visibility as 'public' | 'private',
+        };
+      } else {
+        const remoteUrl = await p.text({
+          message: 'Remote repository URL:',
+          placeholder: 'https://github.com/user/repo.git',
+          validate: (v) => {
+            if (!v || v.trim().length === 0) return 'URL is required';
+            if (!v.startsWith('https://') && !v.startsWith('git@'))
+              return 'URL must start with https:// or git@';
+          },
+        });
+
+        if (p.isCancel(remoteUrl)) return null;
+
+        git.remote = {
+          type: 'manual',
+          url: (remoteUrl as string).trim(),
+        };
+      }
+    }
+  }
+
   return {
-    id,
-    name: name.trim(),
-    role: 'Your universal second brain — learns, remembers, improves',
-    description:
-      'A universal assistant that learns from your projects, captures knowledge, and gets smarter with every session.',
-    domains: [],
-    principles: [],
-    skills: [],
-    tone: 'mentor',
-    greeting,
-    persona,
-  } as AgentConfigInput;
+    config: {
+      id,
+      name: name.trim(),
+      role: 'Your universal second brain — learns, remembers, improves',
+      description:
+        'A universal assistant that learns from your projects, captures knowledge, and gets smarter with every session.',
+      domains: [],
+      principles: [],
+      skills: [],
+      tone: 'mentor',
+      greeting,
+      persona,
+    } as AgentConfigInput,
+    git,
+  };
 }

package/src/utils/checks.ts

@@ -1,15 +1,15 @@
 /**
  * Health check utilities for the doctor command.
  */
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
-import { detectAgent } from './agent-context.js';
+import { detectAgent, type AgentFormat } from './agent-context.js';
 import { getInstalledPacks } from '../hook-packs/registry.js';
 
-interface CheckResult {
-  status: 'pass' | 'fail' | 'warn';
+export interface CheckResult {
+  status: 'pass' | 'fail' | 'warn' | 'skip';
   label: string;
   detail?: string;
 }
@@ -53,10 +53,19 @@ export function checkAgentProject(dir?: string): CheckResult {
   if (!ctx) {
     return { status: 'warn', label: 'Agent project', detail: 'not detected in current directory' };
   }
-  return { status: 'pass', label: 'Agent project', detail: `${ctx.agentId} (${ctx.packageName})` };
+  const formatLabel = ctx.format === 'filetree' ? 'file-tree' : 'typescript';
+  return {
+    status: 'pass',
+    label: 'Agent project',
+    detail: `${ctx.agentId} (${ctx.packageName}, ${formatLabel})`,
+  };
 }
 
-export function checkAgentBuild(dir?: string): CheckResult {
+export function checkAgentBuild(dir?: string, format?: AgentFormat): CheckResult {
+  if (format === 'filetree') {
+    return { status: 'skip', label: 'Agent build', detail: 'not applicable for file-tree agents' };
+  }
+
   const ctx = detectAgent(dir);
   if (!ctx) return { status: 'warn', label: 'Agent build', detail: 'no agent detected' };
 
@@ -73,7 +82,15 @@ export function checkAgentBuild(dir?: string): CheckResult {
   return { status: 'pass', label: 'Agent build', detail: 'dist/index.js exists' };
 }
 
-export function checkNodeModules(dir?: string): CheckResult {
+export function checkNodeModules(dir?: string, format?: AgentFormat): CheckResult {
+  if (format === 'filetree') {
+    return {
+      status: 'skip',
+      label: 'Dependencies',
+      detail: 'not applicable for file-tree agents',
+    };
+  }
+
   const ctx = detectAgent(dir);
   if (!ctx) return { status: 'warn', label: 'Dependencies', detail: 'no agent detected' };
 
@@ -87,6 +104,80 @@ export function checkNodeModules(dir?: string): CheckResult {
   return { status: 'pass', label: 'Dependencies', detail: 'node_modules/ exists' };
 }
 
+export function checkAgentYaml(agentPath: string): CheckResult {
+  const yamlPath = join(agentPath, 'agent.yaml');
+  if (!existsSync(yamlPath)) {
+    return { status: 'fail', label: 'agent.yaml', detail: 'not found' };
+  }
+
+  try {
+    const content = readFileSync(yamlPath, 'utf-8');
+    // Light validation: check for required fields without pulling in a YAML parser
+    // (detectAgent already parsed it, but we verify the raw content for diagnostics)
+    const hasId = /^id\s*:/m.test(content);
+    const hasName = /^name\s*:/m.test(content);
+
+    if (!hasId && !hasName) {
+      return {
+        status: 'fail',
+        label: 'agent.yaml',
+        detail: 'missing required fields: id, name',
+      };
+    }
+    if (!hasId) {
+      return { status: 'fail', label: 'agent.yaml', detail: 'missing required field: id' };
+    }
+    if (!hasName) {
+      return { status: 'fail', label: 'agent.yaml', detail: 'missing required field: name' };
+    }
+    return { status: 'pass', label: 'agent.yaml', detail: 'valid (id, name present)' };
+  } catch {
+    return { status: 'fail', label: 'agent.yaml', detail: 'failed to read file' };
+  }
+}
+
+export function checkInstructionsDir(agentPath: string): CheckResult {
+  const instrDir = join(agentPath, 'instructions');
+  if (!existsSync(instrDir)) {
+    return {
+      status: 'fail',
+      label: 'Instructions',
+      detail: 'instructions/ directory not found',
+    };
+  }
+
+  try {
+    const files = readdirSync(instrDir).filter((f) => f.endsWith('.md'));
+    if (files.length === 0) {
+      return {
+        status: 'warn',
+        label: 'Instructions',
+        detail: 'instructions/ exists but contains no .md files',
+      };
+    }
+    return {
+      status: 'pass',
+      label: 'Instructions',
+      detail: `${files.length} instruction file${files.length === 1 ? '' : 's'}`,
+    };
+  } catch {
+    return { status: 'fail', label: 'Instructions', detail: 'failed to read instructions/' };
+  }
+}
+
+export function checkEngineReachable(): CheckResult {
+  try {
+    require.resolve('@soleri/core/package.json');
+    return { status: 'pass', label: 'Engine', detail: '@soleri/core reachable' };
+  } catch {
+    return {
+      status: 'fail',
+      label: 'Engine',
+      detail: '@soleri/core not found — engine is required for file-tree agents',
+    };
+  }
+}
+
 function checkMcpRegistration(dir?: string): CheckResult {
   const ctx = detectAgent(dir);
   if (!ctx) return { status: 'warn', label: 'MCP registration', detail: 'no agent detected' };
@@ -157,15 +248,33 @@ function checkHookPacks(): CheckResult {
 }
 
 export function runAllChecks(dir?: string): CheckResult[] {
-  return [
+  const ctx = detectAgent(dir);
+  const format = ctx?.format;
+
+  // Common checks for all agent formats
+  const results: CheckResult[] = [
     checkNodeVersion(),
     checkNpm(),
     checkTsx(),
     checkAgentProject(dir),
-    checkNodeModules(dir),
-    checkAgentBuild(dir),
-    checkMcpRegistration(dir),
-    checkHookPacks(),
-    checkCognee(),
   ];
+
+  if (format === 'filetree') {
+    // File-tree agent checks
+    results.push(
+      checkAgentYaml(ctx!.agentPath),
+      checkInstructionsDir(ctx!.agentPath),
+      checkEngineReachable(),
+      checkNodeModules(dir, format),
+      checkAgentBuild(dir, format),
+    );
+  } else {
+    // TypeScript agent checks (or no agent detected)
+    results.push(checkNodeModules(dir, format), checkAgentBuild(dir, format));
+  }
+
+  // Shared checks
+  results.push(checkMcpRegistration(dir), checkHookPacks(), checkCognee());
+
+  return results;
 }

package/src/utils/format-paths.ts

@@ -0,0 +1,41 @@
+/**
+ * Format-aware path resolution for filetree vs typescript agents.
+ */
+import { join } from 'node:path';
+
+export interface FormatPaths {
+  knowledgeDir: string;
+  extensionsDir: string;
+  facadesDir: string;
+  agentConfigFile: string;
+  entryPoint: string;
+}
+
+export function getFormatPaths(ctx: {
+  format: 'filetree' | 'typescript';
+  agentPath: string;
+}): FormatPaths {
+  const { format, agentPath } = ctx;
+
+  if (format === 'filetree') {
+    return {
+      knowledgeDir: join(agentPath, 'knowledge'),
+      extensionsDir: join(agentPath, 'extensions'),
+      facadesDir: '',
+      agentConfigFile: join(agentPath, 'agent.yaml'),
+      entryPoint: join(agentPath, 'agent.yaml'),
+    };
+  }
+
+  return {
+    knowledgeDir: join(agentPath, 'src', 'intelligence', 'data'),
+    extensionsDir: join(agentPath, 'src', 'extensions'),
+    facadesDir: join(agentPath, 'src', 'facades'),
+    agentConfigFile: join(agentPath, 'package.json'),
+    entryPoint: join(agentPath, 'src', 'index.ts'),
+  };
+}
+
+export function isFileTree(ctx: { format: string }): boolean {
+  return ctx.format === 'filetree';
+}