@sage-protocol/cli 0.3.10 → 0.4.1

package/dist/cli/services/metaprompt/anthropic-client.js

@@ -0,0 +1,87 @@
+let Anthropic;
+try {
+  // Lazy / guarded require so OpenAI-only setups don't crash on import
+  // eslint-disable-next-line global-require
+  Anthropic = require('@anthropic-ai/sdk');
+} catch (err) {
+  // Defer error until someone actually tries to construct the client
+  Anthropic = null;
+}
+
+/**
+ * Client for interacting with Anthropic's Claude API.
+ * Follows the ModelClient interface.
+ */
+class AnthropicClient {
+  /**
+   * @param {object} config
+   * @param {string} config.apiKey
+   * @param {string} [config.model]
+   * @param {number} [config.temperature]
+   */
+  constructor({ apiKey, model, temperature }) {
+    if (!Anthropic) {
+      throw new Error('Anthropic SDK not installed. Please add @anthropic-ai/sdk or configure a different provider.');
+    }
+    this.apiKey = apiKey;
+    this.model = model || 'claude-sonnet-4-20250514';
+    this.temperature = temperature ?? 0.7;
+    
+    this.client = new Anthropic({
+      apiKey: this.apiKey,
+    });
+  }
+
+  /**
+   * Stream chat completion.
+   * @param {Array<{role:string, content:string}>} messages
+   * @param {(token:string) => void} [onToken] Callback for each token
+   * @returns {Promise<string>} Full response text
+   */
+  async streamChat(messages, onToken) {
+    // Convert 'developer' role to 'system' property, as Anthropic handles system prompts separately
+    const systemMessage = messages.find(m => m.role === 'system' || m.role === 'developer');
+    const userAssistantMessages = messages.filter(m => m.role !== 'system' && m.role !== 'developer');
+
+    const stream = await this.client.messages.create({
+      model: this.model,
+      system: systemMessage ? systemMessage.content : undefined,
+      messages: userAssistantMessages,
+      max_tokens: 4096,
+      temperature: this.temperature,
+      stream: true,
+    });
+
+    let fullText = '';
+    for await (const chunk of stream) {
+      if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
+        const content = chunk.delta.text;
+        fullText += content;
+        if (onToken) onToken(content);
+      }
+    }
+    return fullText;
+  }
+
+  /**
+   * Non-streaming chat completion.
+   * @param {Array<{role:string, content:string}>} messages
+   * @returns {Promise<string>} Full response text
+   */
+  async complete(messages) {
+    const systemMessage = messages.find(m => m.role === 'system' || m.role === 'developer');
+    const userAssistantMessages = messages.filter(m => m.role !== 'system' && m.role !== 'developer');
+
+    const response = await this.client.messages.create({
+      model: this.model,
+      system: systemMessage ? systemMessage.content : undefined,
+      messages: userAssistantMessages,
+      max_tokens: 4096,
+      temperature: this.temperature,
+    });
+
+    return response.content[0].text || '';
+  }
+}
+
+module.exports = AnthropicClient;

package/dist/cli/services/metaprompt/interview-driver.js

@@ -0,0 +1,161 @@
+const { createModelClient } = require('./model-client');
+const SlotPlanner = require('./slot-planner');
+const PromptBuilder = require('./prompt-builder');
+
+class InterviewDriver {
+  /**
+   * @param {object} config CLI config object
+   * @param {object} [options]
+   * @param {string} [options.templateKey]
+   * @param {string} [options.initialDescription]
+   * @param {string} [options.provider]
+   * @param {string} [options.model]
+   * @param {string} [options.apiKey]
+   */
+  constructor(config, options = {}) {
+    this.config = config;
+    this.client = createModelClient(config, {
+      provider: options.provider,
+      model: options.model,
+      apiKey: options.apiKey,
+    });
+    this.planner = new SlotPlanner(config, {
+      client: this.client,
+      provider: options.provider,
+      model: options.model,
+      apiKey: options.apiKey,
+    });
+    this.builder = new PromptBuilder();
+    
+    this.templateKey = options.templateKey || 'custom';
+    this.initialDescription = options.initialDescription || '';
+    this.transcript = [];
+    this.slots = []; // The plan
+    this.answers = {}; // The state of filled slots
+    this.isDone = false;
+  }
+  /**
+   * Initialize the driver. Call this before using getNextQuestion().
+   * @param {object} [precomputedState] Optional pre-existing state to restore
+   * @param {Array} [precomputedState.slots] Pre-computed slots (skips LLM planning)
+   * @param {object} [precomputedState.answers] Pre-filled answers
+   * @param {Array} [precomputedState.transcript] Prior transcript
+   */
+  async init(precomputedState = null) {
+    // If we have precomputed state, restore it (skip expensive LLM planning)
+    if (precomputedState && precomputedState.slots && precomputedState.slots.length > 0) {
+      this.slots = precomputedState.slots;
+      this.answers = precomputedState.answers || {};
+      this.transcript = precomputedState.transcript || [];
+      return;
+    }
+
+    // 1. Generate Plan (uses LLM for custom templates, static for built-ins)
+    this.slots = await this.planner.planSlots(this.templateKey, this.initialDescription);
+
+    // 2. Check if initialDescription fills any slots immediately (One-shot extraction)
+    if (this.initialDescription) {
+      await this.#extractFromText(this.initialDescription);
+    }
+  }
+
+  async getNextQuestion() {
+    if (this.isDone) return null;
+
+    // 1. Find highest priority slot that is required and empty
+    const nextSlot = this.slots.find(s => s.required && !this.answers[s.key]);
+    
+    if (!nextSlot) {
+      // All required slots filled. Check optional high priority?
+      const optionalSlot = this.slots.find(s => !this.answers[s.key] && s.priority <= 2);
+      if (optionalSlot) {
+        return await this.#generateQuestion(optionalSlot);
+      }
+      
+      // If we are here, we are effectively done with the structured part.
+      this.isDone = true;
+      return null;
+    }
+
+    return await this.#generateQuestion(nextSlot);
+  }
+
+  async processAnswer(answer) {
+    this.transcript.push({ role: 'user', content: answer });
+    await this.#extractFromText(answer); // Extract whatever we can from the answer
+  }
+
+  generateSystemPrompt() {
+    return this.builder.buildSystemPrompt(this.templateKey, this.slots, this.answers);
+  }
+
+  // --- Private Helpers ---
+
+  async #generateQuestion(slot) {
+    const systemPrompt = `
+You are an expert interviewer. Your goal is to extract specific information from the user to build an AI persona.
+Current Target: "${slot.label}" (${slot.description})
+Context So Far: ${JSON.stringify(this.answers)}
+
+Generate a single, clear, friendly question to ask the user for this information.
+Do not preface it with "Question:" or similar. Just ask.
+`;
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: 'Ask the question.' }
+    ];
+    
+    const question = await this.client.complete(messages);
+    this.transcript.push({ role: 'assistant', content: question });
+    return question;
+  }
+
+  async #extractFromText(text) {
+    // Use LLM to map text to slots
+    // We send the schema + current answers + text
+    // Use JSON.stringify for the text to handle quotes, braces, and special chars safely
+    const emptySlots = this.slots.filter(s => !this.answers[s.key]);
+    if (emptySlots.length === 0) return;
+
+    const systemPrompt = `
+You are a data extraction engine.
+Slots Schema: ${JSON.stringify(emptySlots)}
+(Only extract for empty slots, but update existing if new info is better).
+
+Input Text: ${JSON.stringify(text)}
+
+Return a JSON object where keys match the slot keys and values are the extracted information.
+If no information is found for a slot, omit the key.
+CRITICAL: Return ONLY a valid JSON object, no markdown, no explanation.
+`;
+
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: 'Extract data from the input text.' }
+    ];
+
+    try {
+      const response = await this.client.complete(messages);
+      // Try to find a JSON object in the response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return;
+
+      const updates = JSON.parse(jsonMatch[0]);
+
+      // Update state
+      for (const [key, val] of Object.entries(updates)) {
+        if (val && (typeof val === 'string' || typeof val === 'object')) {
+          this.answers[key] = typeof val === 'object' ? JSON.stringify(val) : val;
+        }
+      }
+    } catch (e) {
+      // Silent fail - extraction is best-effort
+      if (process.env.SAGE_VERBOSE) {
+        console.warn('Extraction failed:', e.message);
+      }
+    }
+  }
+}
+
+module.exports = InterviewDriver;
+

package/dist/cli/services/metaprompt/model-client.js

@@ -0,0 +1,49 @@
+const OpenAIClient = require('./openai-client');
+const AnthropicClient = require('./anthropic-client');
+
+/**
+ * Factory to create the appropriate ModelClient based on available keys.
+ * @param {object} config The config object (from require('../../config'))
+ * @param {object} [overrides] Optional overrides for testing or CLI flags
+ * @param {string} [overrides.provider] 'openai' | 'anthropic'
+ * @param {string} [overrides.model]
+ * @param {string} [overrides.apiKey]
+ * @returns {OpenAIClient|AnthropicClient}
+ */
+function createModelClient(config, overrides = {}) {
+  // 1. Explicit override
+  if (overrides.provider && overrides.apiKey) {
+    if (overrides.provider === 'anthropic') {
+      return new AnthropicClient({ apiKey: overrides.apiKey, model: overrides.model });
+    }
+    if (overrides.provider === 'openai') {
+      return new OpenAIClient({ apiKey: overrides.apiKey, model: overrides.model });
+    }
+  }
+
+  // 2. Config-based resolution
+  const aiConfig = config.readAIConfig();
+  
+  // Prefer explicit provider override if key is in config
+  if (overrides.provider === 'anthropic' && aiConfig.anthropicApiKey) {
+    return new AnthropicClient({ apiKey: aiConfig.anthropicApiKey, model: overrides.model });
+  }
+  if (overrides.provider === 'openai' && aiConfig.openaiApiKey) {
+    return new OpenAIClient({ apiKey: aiConfig.openaiApiKey, model: overrides.model });
+  }
+
+  // 3. Default preference: Anthropic > OpenAI
+  if (aiConfig.anthropicApiKey) {
+    return new AnthropicClient({ apiKey: aiConfig.anthropicApiKey, model: overrides.model });
+  }
+  if (aiConfig.openaiApiKey) {
+    return new OpenAIClient({ apiKey: aiConfig.openaiApiKey, model: overrides.model });
+  }
+
+  throw new Error(
+    'No AI keys found. Please run `sage config ai set --provider anthropic --key <sk-ant-...>` or set ANTHROPIC_API_KEY.'
+  );
+}
+
+module.exports = { createModelClient };
+

package/dist/cli/services/metaprompt/openai-client.js

@@ -0,0 +1,67 @@
+const OpenAI = require('openai');
+
+/**
+ * Client for interacting with OpenAI's chat API.
+ * Follows the ModelClient interface:
+ * - streamChat(messages, onToken): Promise<fullText>
+ * - complete(messages): Promise<fullText>
+ */
+class OpenAIClient {
+  /**
+   * @param {object} config
+   * @param {string} config.apiKey
+   * @param {string} [config.model]
+   * @param {number} [config.temperature]
+   */
+  constructor({ apiKey, model, temperature }) {
+    this.apiKey = apiKey;
+    this.model = model || 'gpt-4o';
+    this.temperature = temperature ?? 0.7;
+    
+    this.client = new OpenAI({
+      apiKey: this.apiKey,
+    });
+  }
+
+  /**
+   * Stream chat completion.
+   * @param {Array<{role:string, content:string}>} messages
+   * @param {(token:string) => void} [onToken] Callback for each token
+   * @returns {Promise<string>} Full response text
+   */
+  async streamChat(messages, onToken) {
+    const stream = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      temperature: this.temperature,
+      stream: true,
+    });
+
+    let fullText = '';
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content || '';
+      if (content) {
+        fullText += content;
+        if (onToken) onToken(content);
+      }
+    }
+    return fullText;
+  }
+
+  /**
+   * Non-streaming chat completion.
+   * @param {Array<{role:string, content:string}>} messages
+   * @returns {Promise<string>} Full response text
+   */
+  async complete(messages) {
+    const completion = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      temperature: this.temperature,
+    });
+    return completion.choices[0]?.message?.content || '';
+  }
+}
+
+module.exports = OpenAIClient;
+

package/dist/cli/services/metaprompt/persistence.js

@@ -0,0 +1,86 @@
+const fs = require('fs');
+const path = require('path');
+
+class MetapromptPersistence {
+  constructor(config) {
+    this.config = config;
+    this.projectDir = config.getProjectDir();
+  }
+
+  getPaths(slug) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return {
+      metaprompt: path.join(this.projectDir, '.sage', 'metaprompts', `${slug}.md`),
+      skill: path.join(this.projectDir, 'prompts', 'skills', `${slug}.md`),
+      history: path.join(this.projectDir, '.sage', 'metaprompts', 'history', `${slug}-${timestamp}.json`),
+    };
+  }
+
+  saveMetaprompt(slug, data) {
+    const paths = this.getPaths(slug);
+    
+    // Ensure dirs
+    fs.mkdirSync(path.dirname(paths.metaprompt), { recursive: true });
+    fs.mkdirSync(path.dirname(paths.history), { recursive: true });
+
+    // 1. Save history JSON (The "Metaprompt Artifact")
+    fs.writeFileSync(paths.history, JSON.stringify(data, null, 2));
+
+    // 2. Save readable Markdown Metaprompt (Source of Truth)
+    const mdContent = `---
+slug: ${slug}
+template: ${data.templateKey}
+date: ${new Date().toISOString()}
+---
+
+# Metaprompt Session: ${slug}
+
+## Transcript
+${data.transcript.map(t => `**${t.role.toUpperCase()}**: ${t.content}`).join('\n\n')}
+
+## Filled Slots
+\`\`\`json
+${JSON.stringify(data.answers, null, 2)}
+\`\`\`
+`;
+    fs.writeFileSync(paths.metaprompt, mdContent);
+    
+    return paths;
+  }
+
+  saveSkill(slug, systemPrompt) {
+    const paths = this.getPaths(slug);
+    fs.mkdirSync(path.dirname(paths.skill), { recursive: true });
+
+    const content = `---
+title: ${slug} (Generated Agent)
+description: Generated via sage interview
+---
+
+${systemPrompt}
+`;
+    fs.writeFileSync(paths.skill, content);
+    return paths.skill;
+  }
+
+  appendToAgentsList(slug) {
+    const agentsPath = path.join(this.projectDir, 'prompts', 'agents.md');
+    const dir = path.dirname(agentsPath);
+    if (!fs.existsSync(dir)) return;
+
+    const entry = `- [${slug}](./skills/${slug}.md)`;
+    let existing = '';
+    if (fs.existsSync(agentsPath)) {
+      try {
+        existing = fs.readFileSync(agentsPath, 'utf8');
+        if (existing.includes(entry)) return; // avoid duplicates
+      } catch (_) {
+        existing = '';
+      }
+    }
+    const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+    fs.appendFileSync(agentsPath, `${prefix}${entry}\n`);
+  }
+}
+
+module.exports = MetapromptPersistence;

package/dist/cli/services/metaprompt/prompt-builder.js

@@ -0,0 +1,186 @@
+const templates = require('./templates.json');
+
+/**
+ * Mapping of slot groups to section names and order.
+ * This normalizes the various group names used in templates.
+ */
+const GROUP_MAPPINGS = {
+  // Identity-related
+  'identity': 'identity',
+  'role': 'identity',
+
+  // Goals-related
+  'goals': 'goals',
+  'goal': 'goals',
+
+  // Context-related
+  'context': 'context',
+  'stack': 'context',
+
+  // Constraints-related
+  'constraints': 'constraints',
+  'guidelines': 'constraints',
+
+  // Tools-related
+  'tools': 'tools',
+
+  // Output-related
+  'output': 'output',
+  'format': 'output',
+};
+
+/**
+ * Tool definitions for inject_tools feature.
+ * Maps tool names to descriptions.
+ */
+const TOOL_DEFINITIONS = {
+  'sage prompts': '`sage prompts`: Workspace-first prompt and skill management (init, list, diff, publish).',
+  'sage project': '`sage project`: Manifest management, IPFS publishing, and governance proposal helpers.',
+  'sage governance': '`sage governance`: Governance commands for viewing proposals, voting, and managing SubDAOs.',
+  'sage gov': '`sage gov`: Alias for sage governance - proposal management and voting.',
+  'sage treasury': '`sage treasury`: Treasury inspection, withdrawals, boosts, and bond operations.',
+  'sage ipfs': '`sage ipfs`: IPFS operations including pinning, fetching, and gateway management.',
+  'sage dev': '`sage dev`: Development commands for building, testing, and deploying.',
+  'sage config': '`sage config`: Configuration management for RPC, wallets, and AI providers.',
+  'sage mcp': '`sage mcp`: MCP server management for agent integrations.',
+};
+
+class PromptBuilder {
+  constructor() {
+    // Could be extended to load custom tool definitions
+  }
+
+  /**
+   * Builds the final system prompt string from the filled slots.
+   * @param {string} templateKey
+   * @param {Array} slots - Definition of slots
+   * @param {Object} answers - Key-value pairs of filled answers
+   * @returns {string} The final XML-structured system prompt
+   */
+  buildSystemPrompt(templateKey, slots, answers) {
+    const template = templates[templateKey] || templates['custom'];
+
+    // Build sections in order
+    const sections = [];
+
+    // 1. Role/Identity section
+    const identityContent = this.#buildGroupSection(slots, answers, 'identity');
+    const roleContent = this.#getAnswer(answers, 'role') || identityContent || template.description;
+    if (roleContent) {
+      sections.push(this.#buildSection('role', roleContent));
+    }
+
+    // 2. Goals section
+    const goalsContent = this.#buildGroupSection(slots, answers, 'goals');
+    const goalContent = this.#getAnswer(answers, 'goal') || goalsContent || template.default_goal;
+    if (goalContent) {
+      sections.push(this.#buildSection('goals', goalContent));
+    }
+
+    // 3. Context section (tech stack, data sources, etc.)
+    const contextSection = this.#buildGroupSection(slots, answers, 'context');
+    if (contextSection) {
+      sections.push(this.#buildSection('context', contextSection));
+    }
+
+    // 4. Constraints section
+    const constraintsSection = this.#buildGroupSection(slots, answers, 'constraints');
+    if (constraintsSection) {
+      sections.push(this.#buildSection('constraints', constraintsSection));
+    }
+
+    // 5. Tools section
+    const toolsSection = this.#buildToolsSection(template.inject_tools, answers, slots);
+    if (toolsSection) {
+      sections.push(toolsSection);
+    }
+
+    // 6. Output format section
+    const outputSection = this.#buildGroupSection(slots, answers, 'output');
+    if (outputSection) {
+      sections.push(this.#buildSection('output_format', outputSection));
+    }
+
+    // 7. Final reminder
+    sections.push(`Remember: You are ${template.name}. Stay in character and follow your constraints.`);
+
+    return sections.filter(Boolean).join('\n\n');
+  }
+
+  #getAnswer(answers, key) {
+    return answers[key] || '';
+  }
+
+  #buildSection(title, content) {
+    if (!content) return '';
+    const tag = this.#sanitizeTag(title);
+    return `<${tag}>\n${content}\n</${tag}>`;
+  }
+
+  #sanitizeTag(title) {
+    // Remove special chars, replace spaces with underscores, lowercase
+    return title.toLowerCase().replace(/[^a-z0-9_]/g, '_').replace(/_+/g, '_');
+  }
+
+  /**
+   * Build a section from all slots matching a normalized group.
+   */
+  #buildGroupSection(slots, answers, normalizedGroup) {
+    // Find slots matching this group (handling group name variations)
+    const groupSlots = slots.filter(slot => {
+      const slotGroup = (slot.group || '').toLowerCase();
+      const mapped = GROUP_MAPPINGS[slotGroup] || slotGroup;
+      return mapped === normalizedGroup;
+    });
+
+    if (!groupSlots.length) return '';
+
+    const lines = groupSlots.map(slot => {
+      const ans = answers[slot.key];
+      if (!ans) return null;
+      return `- **${slot.label}**: ${ans}`;
+    }).filter(Boolean);
+
+    return lines.length ? lines.join('\n') : '';
+  }
+
+  #buildToolsSection(injectedTools = [], answers, slots) {
+    const definitions = [];
+
+    // Add injected tools from template
+    for (const tool of injectedTools) {
+      const def = TOOL_DEFINITIONS[tool];
+      if (def) {
+        definitions.push(`- ${def}`);
+      } else {
+        // Unknown tool - add a generic entry
+        definitions.push(`- \`${tool}\`: Available tool (see documentation).`);
+      }
+    }
+
+    // Add tools from slots with 'tools' group
+    const toolSlots = slots.filter(s => GROUP_MAPPINGS[s.group] === 'tools');
+    for (const slot of toolSlots) {
+      const ans = answers[slot.key];
+      if (ans && !definitions.some(d => d.includes(ans))) {
+        definitions.push(`- ${ans}`);
+      }
+    }
+
+    // Add generic tool answer if provided
+    if (answers.tools && !definitions.some(d => d.includes(answers.tools))) {
+      definitions.push(`- ${answers.tools}`);
+    }
+
+    if (!definitions.length) return '';
+
+    return `<tools>
+You have access to the following tools and capabilities:
+${definitions.join('\n')}
+
+Use these tools when appropriate to fulfill the user's request.
+</tools>`;
+  }
+}
+
+module.exports = PromptBuilder;