@soleri/forge 5.10.0 → 5.12.0

package/src/templates/setup-script.ts

@@ -2,51 +2,24 @@ import type { AgentConfig } from '../types.js';
 
 /**
  * Generate a scripts/setup.sh for the scaffolded agent.
- * Handles: Node.js check, build, Claude Code MCP server registration.
+ * Handles: Node.js check, build, and host-specific MCP registration.
  */
 export function generateSetupScript(config: AgentConfig): string {
-  return `#!/usr/bin/env bash
-set -euo pipefail
-
-AGENT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
-AGENT_NAME="${config.id}"
-
-echo "=== ${config.name} Setup ==="
-echo ""
-
-# Check Node.js
-if ! command -v node &>/dev/null; then
-  echo "Error: Node.js is not installed. Install Node.js 18+ first."
-  exit 1
-fi
-
-NODE_VERSION=$(node -v | sed 's/v//' | cut -d. -f1)
-if [ "$NODE_VERSION" -lt 18 ]; then
-  echo "Error: Node.js 18+ required (found v$(node -v))."
-  exit 1
-fi
-echo "[ok] Node.js $(node -v)"
-
-# Check if built
-if [ ! -f "$AGENT_DIR/dist/index.js" ]; then
-  echo ""
-  echo "Building ${config.name}..."
-  cd "$AGENT_DIR"
-  npm install
-  npm run build
-  echo "[ok] Built successfully"
-else
-  echo "[ok] Already built"
-fi
-
+  const setupTarget = config.setupTarget ?? 'claude';
+  const claudeSetup = setupTarget === 'claude' || setupTarget === 'both';
+  const codexSetup = setupTarget === 'codex' || setupTarget === 'both';
+  const hostLabel =
+    claudeSetup && codexSetup ? 'Claude Code + Codex' : claudeSetup ? 'Claude Code' : 'Codex';
+
+  const claudeSection = claudeSetup
+    ? `
 # Check Claude Code
 if ! command -v claude &>/dev/null; then
   echo ""
   echo "Warning: 'claude' command not found."
   echo "Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code"
   echo ""
-  echo "After installing, add ${config.name} manually to ~/.claude/settings.json"
-  echo "(see README.md for the JSON config)"
+  echo "After installing, re-run this setup script."
   exit 1
 fi
 echo "[ok] Claude Code found"
@@ -54,14 +27,13 @@ echo "[ok] Claude Code found"
 # Register MCP server with Claude Code
 echo ""
 echo "Registering ${config.name} with Claude Code..."
-
 claude mcp add --scope user "$AGENT_NAME" -- node "$AGENT_DIR/dist/index.js"
-echo "[ok] Registered ${config.name} as MCP server"
+echo "[ok] Registered ${config.name} as MCP server (Claude Code)"
 
 # Configure PreCompact hook for session capture
 SETTINGS_FILE="$HOME/.claude/settings.json"
 echo ""
-echo "Configuring session capture hook..."
+echo "Configuring Claude session capture hook..."
 
 if [ ! -d "$HOME/.claude" ]; then
   mkdir -p "$HOME/.claude"
@@ -85,7 +57,6 @@ else
   if grep -q "PreCompact" "$SETTINGS_FILE" 2>/dev/null; then
     echo "[ok] PreCompact hook already configured — skipping"
   else
-    # Use node to safely merge hook into existing settings
     node -e "
       const fs = require('fs');
       const settings = JSON.parse(fs.readFileSync('$SETTINGS_FILE', 'utf-8'));
@@ -107,7 +78,7 @@ COMMANDS_DIR="$HOME/.claude/commands"
 
 if [ -d "$SKILLS_DIR" ]; then
   echo ""
-  echo "Installing skills..."
+  echo "Installing skills for Claude Code..."
   mkdir -p "$COMMANDS_DIR"
   skill_installed=0
   skill_skipped=0
@@ -124,12 +95,15 @@ if [ -d "$SKILLS_DIR" ]; then
       skill_installed=$((skill_installed + 1))
     fi
   done
-  echo "[ok] Skills: $skill_installed installed, $skill_skipped already present"
+  echo "[ok] Claude skills: $skill_installed installed, $skill_skipped already present"
 fi
+`
+    : '';
 
-${
-  config.hookPacks?.length
-    ? `# Install hook packs to global ~/.claude/
+  const hookPackSection =
+    claudeSetup && config.hookPacks?.length
+      ? `
+# Install hook packs to global ~/.claude/
 AGENT_CLAUDE_DIR="$AGENT_DIR/.claude"
 GLOBAL_CLAUDE_DIR="$HOME/.claude"
 
@@ -151,16 +125,129 @@ if [ -d "$AGENT_CLAUDE_DIR" ]; then
   done
   echo "[ok] Hooks: $installed installed, $skipped already present"
 fi
-
 `
-    : ''
-}echo ""
-echo "=== Setup Complete ==="
+      : '';
+
+  const codexSection = codexSetup
+    ? `
+# Register MCP server with Codex
 echo ""
-echo "Next:"
-echo "  1. Start a new Claude Code session (or restart if one is open)"
-echo "  2. Say: \\"Hello, ${config.name}!\\""
+echo "Registering ${config.name} with Codex..."
+mkdir -p "$HOME/.codex"
+CODEX_CONFIG="$HOME/.codex/config.toml"
+AGENT_DIST="$AGENT_DIR/dist/index.js"
+
+CODEX_CONFIG="$CODEX_CONFIG" AGENT_NAME="$AGENT_NAME" AGENT_DIST="$AGENT_DIST" node <<'NODE'
+const fs = require('node:fs');
+const path = process.env.CODEX_CONFIG;
+const agentName = process.env.AGENT_NAME;
+const distPath = process.env.AGENT_DIST;
+
+let content = '';
+if (fs.existsSync(path)) {
+  content = fs.readFileSync(path, 'utf-8');
+}
+
+const header = '[mcp_servers.' + agentName + ']';
+const block = header + '\\ncommand = "node"\\nargs = ["' + distPath + '"]\\n';
+const start = content.indexOf(header);
+
+if (start === -1) {
+  const trimmed = content.trimEnd();
+  content = trimmed.length === 0 ? block + '\\n' : trimmed + '\\n\\n' + block + '\\n';
+} else {
+  const afterHeader = start + header.length;
+  const tail = content.slice(afterHeader);
+  const nextSectionOffset = tail.search(/\\n\\[[^\\]]+\\]/);
+  const end = nextSectionOffset === -1 ? content.length : afterHeader + nextSectionOffset;
+  content = content.slice(0, start).trimEnd() + '\\n\\n' + block + '\\n' + content.slice(end).trimStart();
+}
+
+content = content.replace(/\\n{3,}/g, '\\n\\n');
+fs.writeFileSync(path, content, 'utf-8');
+NODE
+echo "[ok] Registered ${config.name} as MCP server (Codex)"
+
+# Install skills to ~/.codex/skills/
+SKILLS_DIR="$AGENT_DIR/skills"
+CODEX_SKILLS_DIR="$HOME/.codex/skills"
+
+if [ -d "$SKILLS_DIR" ]; then
+  echo ""
+  echo "Installing skills for Codex..."
+  mkdir -p "$CODEX_SKILLS_DIR"
+  skill_installed=0
+  skill_skipped=0
+  for skill_dir in "$SKILLS_DIR"/*/; do
+    [ -d "$skill_dir" ] || continue
+    skill_file="$skill_dir/SKILL.md"
+    [ -f "$skill_file" ] || continue
+    skill_name="$(basename "$skill_dir")"
+    dest_dir="$CODEX_SKILLS_DIR/$AGENT_NAME-$skill_name"
+    dest_file="$dest_dir/SKILL.md"
+    if [ -f "$dest_file" ]; then
+      skill_skipped=$((skill_skipped + 1))
+    else
+      mkdir -p "$dest_dir"
+      cp "$skill_file" "$dest_file"
+      skill_installed=$((skill_installed + 1))
+    fi
+  done
+  echo "[ok] Codex skills: $skill_installed installed, $skill_skipped already present"
+fi
+`
+    : '';
+
+  const nextSteps = [
+    'echo ""',
+    'echo "=== Setup Complete ==="',
+    'echo ""',
+    'echo "Next:"',
+    ...(claudeSetup
+      ? ['echo "  - Start a new Claude Code session (or restart if one is open)"']
+      : []),
+    ...(codexSetup ? ['echo "  - Start a new Codex session (or restart if one is open)"'] : []),
+    `echo "  - Say: \\"Hello, ${config.name}!\\""`,
+    'echo ""',
+    `echo "${config.name} is ready."`,
+  ].join('\n');
+
+  return `#!/usr/bin/env bash
+set -euo pipefail
+
+AGENT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+AGENT_NAME="${config.id}"
+
+echo "=== ${config.name} Setup (${hostLabel}) ==="
 echo ""
-echo "${config.name} will activate and guide you from there."
+
+# Check Node.js
+if ! command -v node &>/dev/null; then
+  echo "Error: Node.js is not installed. Install Node.js 18+ first."
+  exit 1
+fi
+
+NODE_VERSION=$(node -v | sed 's/v//' | cut -d. -f1)
+if [ "$NODE_VERSION" -lt 18 ]; then
+  echo "Error: Node.js 18+ required (found v$(node -v))."
+  exit 1
+fi
+echo "[ok] Node.js $(node -v)"
+
+# Check if built
+if [ ! -f "$AGENT_DIR/dist/index.js" ]; then
+  echo ""
+  echo "Building ${config.name}..."
+  cd "$AGENT_DIR"
+  npm install
+  npm run build
+  echo "[ok] Built successfully"
+else
+  echo "[ok] Already built"
+fi
+${claudeSection}
+${hookPackSection}
+${codexSection}
+${nextSteps}
 `;
 }

package/src/templates/skills.ts

@@ -68,26 +68,3 @@ export function generateSkills(config: AgentConfig): Array<[string, string]> {
 
   return files;
 }
-
-/**
- * List all bundled skill names with their descriptions (from YAML frontmatter).
- */
-export function listSkillDescriptions(): Array<{ name: string; description: string }> {
-  let skillFiles: string[];
-
-  try {
-    skillFiles = readdirSync(SKILLS_DIR).filter((f) => f.endsWith('.md'));
-  } catch {
-    return [];
-  }
-
-  return skillFiles.map((file) => {
-    const content = readFileSync(join(SKILLS_DIR, file), 'utf-8');
-    const nameMatch = content.match(/^name:\s*(.+)$/m);
-    const descMatch = content.match(/^description:\s*"?(.+?)"?\s*$/m);
-    return {
-      name: nameMatch?.[1]?.trim() ?? file.replace('.md', ''),
-      description: descMatch?.[1]?.trim() ?? '',
-    };
-  });
-}

package/src/templates/telegram-agent.ts

@@ -0,0 +1,214 @@
+/**
+ * Template: Telegram agent loop — wires @soleri/core agent loop to MCP tools.
+ * Generated by @soleri/forge for agents with Telegram transport.
+ */
+
+import type { AgentConfig } from '../types.js';
+
+export function generateTelegramAgent(config: AgentConfig): string {
+  return `/**
+ * ${config.name} — Telegram Agent Loop.
+ * Generated by @soleri/forge.
+ *
+ * Wires the @soleri/core agent loop to the agent's MCP tools.
+ */
+
+import {
+  runAgentLoop,
+  McpToolBridge,
+  createOutputCompressor,
+} from '@soleri/core';
+import type {
+  ChatMessage,
+  AgentLoopResult,
+  AgentCallbacks,
+  McpToolRegistration,
+} from '@soleri/core';
+import type { TelegramConfig } from './telegram-config.js';
+import { execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+// ─── Core Tools ──────────────────────────────────────────────────────
+
+const CORE_TOOLS: McpToolRegistration[] = [
+  {
+    name: 'bash',
+    description: 'Execute a shell command. Returns stdout/stderr.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Shell command to execute.' },
+        timeout: { type: 'number', description: 'Timeout in ms. Default: 120000.' },
+      },
+      required: ['command'],
+    },
+    handler: async (input) => {
+      try {
+        const timeout = (input.timeout as number) ?? 120_000;
+        const output = execFileSync('/bin/sh', ['-c', input.command as string], {
+          timeout,
+          encoding: 'utf-8',
+          maxBuffer: 1024 * 1024,
+        });
+        return output;
+      } catch (err: unknown) {
+        const error = err as { stdout?: string; stderr?: string; message?: string };
+        return \`Error: \${error.stderr ?? error.stdout ?? error.message ?? 'Unknown error'}\`;
+      }
+    },
+  },
+  {
+    name: 'read_file',
+    description: 'Read a file from the filesystem.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path to read.' },
+      },
+      required: ['path'],
+    },
+    handler: async (input) => {
+      return readFileSync(input.path as string, 'utf-8');
+    },
+  },
+  {
+    name: 'write_file',
+    description: 'Write content to a file.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path to write.' },
+        content: { type: 'string', description: 'Content to write.' },
+      },
+      required: ['path', 'content'],
+    },
+    handler: async (input) => {
+      mkdirSync(dirname(input.path as string), { recursive: true });
+      writeFileSync(input.path as string, input.content as string, 'utf-8');
+      return \`Wrote \${(input.content as string).length} bytes to \${input.path}\`;
+    },
+  },
+  {
+    name: 'glob',
+    description: 'Find files matching a glob pattern.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Glob pattern.' },
+        cwd: { type: 'string', description: 'Working directory.' },
+      },
+      required: ['pattern'],
+    },
+    handler: async (input) => {
+      const cwd = (input.cwd as string) ?? process.cwd();
+      const output = execFileSync('find', ['.', '-path', input.pattern as string, '-type', 'f'], {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 10_000,
+      });
+      const lines = output.trim().split('\\n').filter(Boolean).slice(0, 100);
+      return lines.length > 0 ? lines.join('\\n') : 'No files found.';
+    },
+  },
+  {
+    name: 'grep',
+    description: 'Search file contents with regex.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Regex pattern.' },
+        path: { type: 'string', description: 'File or directory to search.' },
+        type: { type: 'string', description: 'File type filter (e.g., ts, js).' },
+      },
+      required: ['pattern'],
+    },
+    handler: async (input) => {
+      const searchPath = (input.path as string) ?? '.';
+      const args = ['--no-heading', '-n', input.pattern as string, searchPath];
+      if (input.type) args.splice(2, 0, '--type', input.type as string);
+      try {
+        const output = execFileSync('rg', args, {
+          encoding: 'utf-8',
+          timeout: 10_000,
+        });
+        const lines = output.trim().split('\\n').filter(Boolean).slice(0, 50);
+        return lines.length > 0 ? lines.join('\\n') : 'No matches found.';
+      } catch {
+        return 'No matches found.';
+      }
+    },
+  },
+];
+
+// ─── Agent Factory ───────────────────────────────────────────────────
+
+export interface TelegramAgentRunner {
+  run(messages: ChatMessage[], callbacks?: AgentCallbacks): Promise<AgentLoopResult>;
+  registerTool(tool: McpToolRegistration): void;
+  getToolCount(): number;
+}
+
+export function createTelegramAgent(config: TelegramConfig): TelegramAgentRunner {
+  const bridge = new McpToolBridge({
+    compressor: createOutputCompressor({ maxLength: 4000 }),
+    maxOutput: 10_000,
+  });
+
+  // Register core tools
+  bridge.registerAll(CORE_TOOLS);
+
+  const systemPrompt = buildSystemPrompt(config);
+
+  return {
+    run: async (messages: ChatMessage[], callbacks?: AgentCallbacks) => {
+      return runAgentLoop(messages, {
+        apiKey: config.apiKey,
+        model: config.model,
+        systemPrompt,
+        tools: bridge.getTools(),
+        executor: bridge.createExecutor(),
+        maxIterations: config.maxIterations,
+        maxTokens: config.maxTokens,
+      }, callbacks);
+    },
+
+    registerTool: (tool: McpToolRegistration) => {
+      bridge.register(tool);
+    },
+
+    getToolCount: () => bridge.size,
+  };
+}
+
+// ─── System Prompt ───────────────────────────────────────────────────
+
+function buildSystemPrompt(config: TelegramConfig): string {
+  const parts: string[] = [
+    '# ${config.name}',
+    '',
+    '${config.role}',
+    '',
+    '## Environment',
+    \`- Platform: \${process.platform}\`,
+    \`- Working directory: \${config.workingDirectory ?? process.cwd()}\`,
+    \`- Date: \${new Date().toISOString().split('T')[0]}\`,
+    '',
+    '## Telegram Formatting',
+    '- Keep responses concise (under 2000 chars when possible)',
+    '- Use Markdown: **bold**, *italic*, \\\`code\\\`, \\\`\\\`\\\`code blocks\\\`\\\`\\\`',
+    '- Use bullet points for lists',
+    '- No raw JSON in responses — format for human reading',
+    '',
+    '## Available Tools',
+    '- bash: Execute shell commands',
+    '- read_file: Read file contents',
+    '- write_file: Write to files',
+    '- glob: Find files by pattern',
+    '- grep: Search file contents',
+  ];
+
+  return parts.join('\\n');
+}
+`;
+}