@soleri/cli 9.7.2 → 9.8.0

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';
+}

package/src/utils/git.ts

@@ -0,0 +1,118 @@
+/**
+ * Git utility functions for the Soleri CLI scaffold flow.
+ *
+ * Uses child_process.execFile (not exec) for security — no shell interpolation.
+ * Never throws — all functions return { ok, error? } for graceful handling.
+ */
+
+import { execFile } from 'node:child_process';
+
+export interface GitResult {
+  ok: boolean;
+  error?: string;
+}
+
+/** Default timeout for local git operations (30s). */
+const LOCAL_TIMEOUT = 30_000;
+
+/** Timeout for network operations — push, gh create (60s). */
+const NETWORK_TIMEOUT = 60_000;
+
+/**
+ * Run a command via execFile and return stdout on success, or an error string on failure.
+ */
+function run(
+  cmd: string,
+  args: string[],
+  options: { cwd?: string; timeout: number },
+): Promise<{ stdout: string; error?: string }> {
+  return new Promise((resolve) => {
+    try {
+      execFile(
+        cmd,
+        args,
+        {
+          cwd: options.cwd,
+          signal: AbortSignal.timeout(options.timeout),
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            resolve({ stdout: '', error: stderr?.trim() || error.message });
+          } else {
+            resolve({ stdout: stdout ?? '' });
+          }
+        },
+      );
+    } catch (err: unknown) {
+      // execFile itself can throw (e.g. ENOENT)
+      const msg = err instanceof Error ? err.message : String(err);
+      resolve({ stdout: '', error: msg });
+    }
+  });
+}
+
+/** Check if the `git` binary is available on PATH. */
+export async function isGitInstalled(): Promise<boolean> {
+  const { error } = await run('which', ['git'], { timeout: LOCAL_TIMEOUT });
+  return !error;
+}
+
+/** Check if the `gh` (GitHub CLI) binary is available on PATH. */
+export async function isGhInstalled(): Promise<boolean> {
+  const { error } = await run('which', ['gh'], { timeout: LOCAL_TIMEOUT });
+  return !error;
+}
+
+/** Run `git init` in the given directory. */
+export async function gitInit(dir: string): Promise<GitResult> {
+  const { error } = await run('git', ['init'], { cwd: dir, timeout: LOCAL_TIMEOUT });
+  return error ? { ok: false, error } : { ok: true };
+}
+
+/** Stage all files and create an initial commit. */
+export async function gitInitialCommit(dir: string, message: string): Promise<GitResult> {
+  const add = await run('git', ['add', '.'], { cwd: dir, timeout: LOCAL_TIMEOUT });
+  if (add.error) return { ok: false, error: add.error };
+
+  const commit = await run('git', ['commit', '-m', message], { cwd: dir, timeout: LOCAL_TIMEOUT });
+  if (commit.error) return { ok: false, error: commit.error };
+
+  return { ok: true };
+}
+
+/** Add a remote origin URL. */
+export async function gitAddRemote(dir: string, url: string): Promise<GitResult> {
+  const { error } = await run('git', ['remote', 'add', 'origin', url], {
+    cwd: dir,
+    timeout: LOCAL_TIMEOUT,
+  });
+  return error ? { ok: false, error } : { ok: true };
+}
+
+/** Push to origin main with the -u flag. */
+export async function gitPush(dir: string): Promise<GitResult> {
+  const { error } = await run('git', ['push', '-u', 'origin', 'main'], {
+    cwd: dir,
+    timeout: NETWORK_TIMEOUT,
+  });
+  return error ? { ok: false, error } : { ok: true };
+}
+
+/** Create a GitHub repo using the `gh` CLI. */
+export async function ghCreateRepo(
+  name: string,
+  options: { visibility: 'public' | 'private'; dir: string },
+): Promise<GitResult & { url?: string }> {
+  const visFlag = options.visibility === 'public' ? '--public' : '--private';
+  const { stdout, error } = await run(
+    'gh',
+    ['repo', 'create', name, visFlag, `--source=${options.dir}`, '--remote=origin', '--push'],
+    { cwd: options.dir, timeout: NETWORK_TIMEOUT },
+  );
+
+  if (error) return { ok: false, error };
+
+  // gh repo create prints the repo URL on stdout
+  const url = stdout.trim() || undefined;
+  return { ok: true, url };
+}

package/src/utils/logger.ts

@@ -26,6 +26,11 @@ export function warn(label: string, detail?: string): void {
   console.log(`  ${YELLOW}!${RESET} ${label}${suffix}`);
 }
 
+export function skip(label: string, detail?: string): void {
+  const suffix = detail ? ` ${DIM}${detail}${RESET}` : '';
+  console.log(`  ${DIM}–${RESET} ${label}${suffix}`);
+}
+
 export function info(message: string): void {
   console.log(`  ${CYAN}ℹ${RESET} ${message}`);
 }