@sage-protocol/cli 0.4.1 → 0.4.3

package/dist/cli/services/artifact-manager.js

@@ -0,0 +1,198 @@
+
+const fs = require('fs');
+const path = require('path');
+const config = require('../config');
+const { readWorkspace, computeChangeSet } = require('./prompts/workspace');
+
+class ArtifactManager {
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+        this.config = config;
+        this.promptsDir = path.join(this.cwd, 'prompts');
+        this.sageDir = path.join(this.cwd, '.sage');
+    }
+
+    async initialize() {
+        if (!fs.existsSync(this.promptsDir)) fs.mkdirSync(this.promptsDir, { recursive: true });
+    }
+
+    /**
+     * List all artifacts, optionally filtered
+     * @param {Object} filter { kind, publishable }
+     */
+    async listArtifacts(filter = {}) {
+        const artifacts = [];
+        const ws = readWorkspace();
+        const changes = ws ? computeChangeSet(ws) : { added: [], modified: [], removed: [] };
+
+        if (fs.existsSync(this.promptsDir)) {
+            const workspaceFiles = await this._scanDir(this.promptsDir);
+            for (const file of workspaceFiles) {
+                const artifact = await this._parseArtifact(file, ws, changes);
+                if (artifact) artifacts.push(artifact);
+            }
+        }
+
+        return artifacts.filter(a => {
+            if (filter.kind && a.kind !== filter.kind) return false;
+            if (filter.publishable !== undefined && a.publishable !== filter.publishable) return false;
+            return true;
+        });
+    }
+
+    async getArtifact(key) {
+        // Try to find the file. Key could be "skills/coding-helper" -> prompts/skills/coding-helper.md
+        const potentialPath = path.join(this.promptsDir, key + '.md');
+
+        if (fs.existsSync(potentialPath)) {
+            const ws = readWorkspace();
+            const changes = ws ? computeChangeSet(ws) : { added: [], modified: [], removed: [] };
+            return await this._parseArtifact(potentialPath, ws, changes);
+        }
+
+        return null;
+    }
+
+    async saveArtifact(artifact) {
+        const { key, kind, body, meta, targets, publishable } = artifact;
+
+        let relPath = key;
+        if (!relPath.endsWith('.md')) relPath += '.md';
+
+        // Enforce directory conventions
+        if (kind === 'skill' && !relPath.startsWith('skills/')) {
+            relPath = `skills/${relPath}`;
+        } else if (kind === 'snippet' && !relPath.startsWith('snippets/')) {
+            relPath = `snippets/${relPath}`;
+        }
+
+        const filePath = path.join(this.promptsDir, relPath);
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+        // Update meta
+        const frontmatter = {
+            ...meta,
+            kind,
+            publishable: publishable !== undefined ? publishable : (kind === 'prompt'),
+            targets: targets || meta?.targets || []
+        };
+
+        // Construct file content
+        const yaml = Object.entries(frontmatter)
+            .filter(([_, v]) => v !== undefined && v !== null)
+            .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
+            .join('\n');
+
+        const content = `---\n${yaml}\n---\n\n${body}`;
+
+        fs.writeFileSync(filePath, content);
+
+        return this._parseArtifact(filePath);
+    }
+
+    // --- Helpers ---
+
+    async _scanDir(dir, base = '') {
+        let results = [];
+        try {
+            const list = fs.readdirSync(dir);
+            for (const file of list) {
+                const fullPath = path.join(dir, file);
+                const stat = fs.statSync(fullPath);
+                if (stat && stat.isDirectory()) {
+                    results = results.concat(await this._scanDir(fullPath));
+                } else {
+                    if (file.endsWith('.md')) {
+                        results.push(fullPath);
+                    }
+                }
+            }
+        } catch (e) {
+            // ignore if dir doesn't exist
+        }
+        return results;
+    }
+
+    async _parseArtifact(filePath, ws = null, changes = null) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const { attributes, body } = this._parseFrontMatter(content);
+
+            // Infer key from path relative to prompts dir
+            const relative = path.relative(this.promptsDir, filePath);
+            const key = relative.replace(/\.md$/, '');
+
+            // Infer kind
+            let kind = attributes.kind;
+            if (!kind) {
+                if (key.startsWith('skills/') || key.includes('/skills/')) kind = 'skill';
+                else if (key.startsWith('snippets/') || key.includes('/snippets/')) kind = 'snippet';
+                else kind = 'prompt';
+            }
+
+            // Infer publishable
+            // Default: true for prompts, false for skills/snippets
+            let publishable = attributes.publishable;
+            if (publishable === undefined) {
+                publishable = (kind === 'prompt');
+            }
+
+            // Derive publishing state
+            let status = 'unpublished';
+            if (ws && ws.files && ws.files[key]) {
+                if (changes && changes.modified.includes(key)) {
+                    status = 'modified';
+                } else {
+                    status = 'published'; // Assumed synced if in workspace and not modified
+                }
+            } else if (changes && changes.added.includes(key)) {
+                status = 'new';
+            }
+
+            return {
+                key,
+                kind,
+                publishable,
+                body,
+                meta: attributes,
+                targets: attributes.targets || [],
+                publishing: {
+                    status,
+                    lastSynced: ws?.files?.[key]?.mtimeMs || null
+                },
+                filePath
+            };
+        } catch (e) {
+            console.warn(`Failed to parse artifact at ${filePath}: `, e.message);
+            return null;
+        }
+    }
+
+    _parseFrontMatter(content) {
+        const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (match) {
+            const yaml = match[1];
+            const body = match[2];
+            const attributes = {};
+            yaml.split('\n').forEach(line => {
+                const parts = line.split(':');
+                if (parts.length >= 2) {
+                    const k = parts[0].trim();
+                    const v = parts.slice(1).join(':').trim();
+                    if (k && v) {
+                        try {
+                            attributes[k] = JSON.parse(v);
+                        } catch (e) {
+                            attributes[k] = v;
+                        }
+                    }
+                }
+            });
+            return { attributes, body: body.trim() };
+        }
+        return { attributes: {}, body: content.trim() };
+    }
+}
+
+module.exports = ArtifactManager;

package/dist/cli/services/mcp/prompt-result-formatter.js

@@ -23,7 +23,15 @@ function formatUnifiedResults(items = [], { total = 0, page = 1, pageSize = 10 }
     const libraryName = entry?.library?.name ? `   🗂️ Library: ${entry.library.name}\n` : '';
     const cidLine = entry?.cid ? `   🔗 CID: ${entry.cid}\n` : '';
     const origin = entry?.origin || entry?.source || 'unknown';
-    return `${absoluteIndex}. **${promptName}**\n   📜 ${description}\n${libraryName}${cidLine}   🔖 Tags: ${tags}\n   🌐 Source: ${origin}\n`;
+
+    // New unified fields
+    const kind = entry?.kind ? `   🔹 Kind: ${entry.kind}\n` : '';
+    const publishable = entry?.publishable !== undefined ? `   📡 Publishable: ${entry.publishable}\n` : '';
+    const status = entry?.publishing?.status ? `   📊 Status: ${entry.publishing.status}\n` : '';
+    const project = entry?.project ? `   🏗️ Project: ${entry.project}\n` : '';
+    const tools = Array.isArray(entry?.tools) && entry.tools.length ? `   🛠️ Tools: ${entry.tools.join(', ')}\n` : '';
+
+    return `${absoluteIndex}. **${promptName}**\n   📜 ${description}\n${kind}${publishable}${status}${project}${tools}${libraryName}${cidLine}   🔖 Tags: ${tags}\n   🌐 Source: ${origin}\n`;
   }).join('\n');
 
   return head + lines;

package/dist/cli/services/mcp/sage-tool-registry.js

@@ -21,12 +21,12 @@ const TOOL_REGISTRY = {
   },
   list_prompts: {
     category: 'prompt_workspace',
-    keywords: ['list', 'browse', 'prompt', 'workspace'],
+    keywords: ['list', 'browse', 'prompt', 'workspace', 'skill', 'snippet'],
     negativeKeywords: ['search', 'publish'],
-    description: 'List prompts from local workspace and/or on-chain libraries.',
-    whenToUse: 'Use when you want a browseable list of prompts without a specific search query.',
+    description: 'List prompts, skills, or snippets from workspace and/or libraries. Use kind filter for skills.',
+    whenToUse: 'Use when you want to browse prompts. Filter by kind (prompt/skill/snippet) to see specific types.',
     requiredParams: [],
-    optionalParams: ['source', 'library', 'limit'],
+    optionalParams: ['source', 'library', 'limit', 'kind', 'publishable'],
     weight: 0.9,
   },
   get_prompt: {
@@ -79,16 +79,7 @@ const TOOL_REGISTRY = {
     optionalParams: ['variables'],
     weight: 1.0,
   },
-  list_workspace_skills: {
-    category: 'prompt_workspace',
-    keywords: ['skill', 'persona', 'workspace', 'list', 'browse'],
-    negativeKeywords: ['governance', 'publish'],
-    description: 'List skills/personas defined in the current project workspace.',
-    whenToUse: 'Use when you want to see available personas/skills for this project.',
-    requiredParams: [],
-    optionalParams: ['promptsDir'],
-    weight: 1.0,
-  },
+  // NOTE: list_workspace_skills removed - use list_prompts({ kind: 'skill' })
   improve_prompt: {
     category: 'prompt_workspace',
     keywords: ['improve', 'refine', 'quality', 'analyze', 'prompt'],
@@ -109,16 +100,7 @@ const TOOL_REGISTRY = {
     optionalParams: ['newKey', 'name'],
     weight: 0.9,
   },
-  get_workspace_skill: {
-    category: 'prompt_workspace',
-    keywords: ['skill', 'persona', 'workspace', 'get', 'inspect'],
-    negativeKeywords: ['search'],
-    description: 'Load a specific workspace skill by path or key.',
-    whenToUse: 'Use when you know which skill you want to inspect or pass into an agent.',
-    requiredParams: ['path'],
-    optionalParams: [],
-    weight: 1.0,
-  },
+  // NOTE: get_workspace_skill removed - use get_prompt({ key })
 
   // ───────────── Persona / metaprompt tools ─────────────
   list_persona_templates: {
@@ -230,7 +212,7 @@ const TOOL_REGISTRY = {
     keywords: ['publish', 'manifest', 'dao', 'subdao', 'governance'],
     negativeKeywords: [],
     description: 'Prepare a manifest for on-chain publishing and generate CLI commands.',
-    whenToUse: 'Use when you are ready to publish a library/manifest to a SubDAO.',
+    whenToUse: 'Use when you are ready to publish a library/manifest to a DAO.',
     requiredParams: ['manifest'],
     optionalParams: ['subdao', 'description', 'dry_run'],
     weight: 1.2,
@@ -239,7 +221,7 @@ const TOOL_REGISTRY = {
     category: 'governance',
     keywords: ['proposal', 'governance', 'list', 'dao', 'subdao'],
     negativeKeywords: [],
-    description: 'List active proposals for a specific SubDAO.',
+    description: 'List active governance proposals for a specific DAO.',
     whenToUse: 'Use when you want to inspect or track current governance proposals.',
     requiredParams: [],
     optionalParams: ['state', 'subdao', 'limit'],
@@ -249,7 +231,7 @@ const TOOL_REGISTRY = {
     category: 'governance',
     keywords: ['subdao', 'suggest', 'library', 'publish', 'dao'],
     negativeKeywords: [],
-    description: 'Suggest suitable SubDAOs for publishing a given library manifest.',
+    description: 'Suggest suitable DAOs for publishing a given library manifest.',
     whenToUse: 'Use when you have a library and want advice on where to publish it.',
     requiredParams: ['library'],
     optionalParams: ['limit'],
@@ -260,19 +242,19 @@ const TOOL_REGISTRY = {
     keywords: ['publish', 'commands', 'cli', 'dao', 'subdao'],
     negativeKeywords: [],
     description: 'Generate CLI commands for validating, uploading, and proposing a manifest.',
-    whenToUse: 'Use after selecting a SubDAO to get concrete CLI commands for publishing.',
+    whenToUse: 'Use after selecting a DAO to get concrete CLI commands for publishing.',
     requiredParams: ['library'],
     optionalParams: ['target'],
     weight: 1.0,
   },
 
-  // ───────────── Treasury / SubDAO tools ─────────────
+  // ───────────── Treasury / DAO tools ─────────────
   list_subdaos: {
     category: 'treasury',
     keywords: ['subdao', 'dao', 'list', 'treasury', 'governance'],
     negativeKeywords: [],
-    description: 'List all available SubDAOs in the Sage Protocol.',
-    whenToUse: 'Use when you want an overview of existing SubDAOs/treasuries.',
+    description: 'List all available DAOs in the Sage Protocol.',
+    whenToUse: 'Use when you want an overview of existing DAOs and treasuries.',
     requiredParams: [],
     optionalParams: ['limit'],
     weight: 0.9,
@@ -281,14 +263,24 @@ const TOOL_REGISTRY = {
     category: 'treasury',
     keywords: ['subdao', 'library', 'libraries', 'list'],
     negativeKeywords: [],
-    description: 'List libraries associated with a specific SubDAO.',
-    whenToUse: 'Use when you want to see what libraries a SubDAO currently governs.',
+    description: 'List libraries associated with a specific DAO.',
+    whenToUse: 'Use when you want to see what libraries a DAO currently governs.',
     requiredParams: ['subdao'],
     optionalParams: [],
     weight: 1.0,
   },
 
   // ───────────── Discovery / helper tools ─────────────
+  get_project_context: {
+    category: 'discovery',
+    keywords: ['project', 'context', 'workspace', 'config', 'subdao', 'registry'],
+    negativeKeywords: [],
+    description: 'Get context about the current Sage project (root, DAO, artifact counts, etc).',
+    whenToUse: 'Use at session start to understand the project, or before tool selection to check workspace state.',
+    requiredParams: [],
+    optionalParams: [],
+    weight: 1.1,
+  },
   trending_prompts: {
     category: 'discovery',
     keywords: ['trending', 'popular', 'recent', 'discover', 'prompt'],

package/dist/cli/services/mcp/tool-args-validator.js

@@ -44,6 +44,18 @@ function createToolArgsValidator({ zodModule } = {}) {
       page: Z.number().int().min(1).max(100).optional().default(1),
       pageSize: Z.number().int().min(1).max(50).optional().default(10),
     }),
+    list_prompts: Z.object({
+      source: Z.enum(['local', 'workspace', 'onchain', 'all']).optional().default('local'),
+      library: Z.string().max(200).optional().default(''),
+      limit: Z.number().int().min(1).max(100).optional().default(20),
+      kind: Z.enum(['prompt', 'skill', 'snippet']).optional(),
+      publishable: Z.boolean().optional(),
+    }),
+    get_prompt: Z.object({
+      key: Z.string().min(1).max(200),
+      library: Z.string().max(200).optional().default(''),
+    }),
+    get_project_context: Z.object({}),
     get_prompt_content: Z.object({ cid: Z.string().min(10).max(200) }),
     trending_prompts: Z.object({
       limit: Z.number().int().min(1).max(50).optional().default(10),

package/dist/cli/services/project-context.js

@@ -0,0 +1,98 @@
+const path = require('path');
+const fs = require('fs');
+const config = require('../config');
+const ArtifactManager = require('./artifact-manager');
+
+class ProjectContextService {
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+        this.config = config;
+        this.artifactManager = new ArtifactManager(cwd);
+    }
+
+    async getProjectContext() {
+        await this.artifactManager.initialize();
+
+        // Basic Project Info
+        const projectRoot = this.cwd;
+        const promptsDir = path.join(this.cwd, 'prompts');
+
+        // Load Sage Config
+        const profiles = this.config.readProfiles();
+        const activeProfile = profiles.profiles?.[profiles.activeProfile] || {};
+
+        // Load Workspace Config (.sage/workspace.json)
+        let workspaceConfig = {};
+        try {
+            const workspacePath = path.join(this.cwd, '.sage', 'workspace.json');
+            if (fs.existsSync(workspacePath)) {
+                workspaceConfig = JSON.parse(fs.readFileSync(workspacePath, 'utf8'));
+            }
+        } catch (e) {
+            // ignore
+        }
+
+        // Artifact Counts
+        const artifacts = await this.artifactManager.listArtifacts({});
+        const counts = {
+            promptCount: artifacts.filter(a => a.kind === 'prompt').length,
+            skillCount: artifacts.filter(a => a.kind === 'skill').length,
+            snippetCount: artifacts.filter(a => a.kind === 'snippet').length,
+            total: artifacts.length
+        };
+
+        // Libraries (from workspace config or local discovery)
+        // For now, just return what's in workspace config or empty
+        const libraries = workspaceConfig.libraries || [];
+
+        // Get addresses from profile
+        const addresses = activeProfile.addresses || {};
+
+        // Agent surfaces: where other tools expect configuration / rules
+        const agentSurfaces = {
+            cursorRulesDir: null,
+            claudeManifest: null,
+            copilotPromptsDir: null,
+            agentsFiles: [],
+        };
+
+        const cursorRulesDir = path.join(this.cwd, '.cursor', 'rules');
+        if (fs.existsSync(cursorRulesDir)) {
+            agentSurfaces.cursorRulesDir = '.cursor/rules';
+        }
+
+        const claudePath = path.join(this.cwd, 'CLAUDE.md');
+        if (fs.existsSync(claudePath)) {
+            agentSurfaces.claudeManifest = 'CLAUDE.md';
+        }
+
+        const copilotDir = path.join(this.cwd, '.github', 'prompts');
+        if (fs.existsSync(copilotDir)) {
+            agentSurfaces.copilotPromptsDir = '.github/prompts';
+        }
+
+        const agentsPath = path.join(this.cwd, 'AGENTS.md');
+        if (fs.existsSync(agentsPath)) {
+            agentSurfaces.agentsFiles.push('AGENTS.md');
+        }
+
+        return {
+            projectRoot,
+            promptsDir: 'prompts', // relative
+            subdao: addresses.SUBDAO || workspaceConfig.subdao || null,
+            registry: addresses.LIBRARY_REGISTRY || addresses.REGISTRY || workspaceConfig.registry || null,
+            network: process.env.SAGE_NETWORK || 'base-sepolia',
+            rpcUrl: activeProfile.rpcUrl || null,
+            workspace: counts,
+            libraries,
+            agentSurfaces,
+        };
+    }
+
+    // Backwards compatibility for any callers still using getContext()
+    async getContext() {
+        return this.getProjectContext();
+    }
+}
+
+module.exports = ProjectContextService;

package/dist/cli/utils/aliases.js

@@ -106,12 +106,6 @@ const COMMAND_CATALOG = {
       ex: 'examples'
     }
   },
-  prompt: {
-    aliases: ['p'],
-    needsSubcommand: true,
-    subcommands: ['list', 'show', 'pull', 'push', 'publish', 'propose', 'doctor', 'run', 'test', 'preview', 'validate', 'compare', 'fork'],
-    subcommandAliases: { ls: 'list' }
-  },
   dev: {
     aliases: [],
     needsSubcommand: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sage-protocol/cli",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Sage Protocol CLI for managing AI prompt libraries",
   "bin": {
     "sage": "./bin/sage.js"

package/dist/cli/commands/prompt-test.js

@@ -1,176 +0,0 @@
-const { Command } = require('commander');
-const fs = require('fs');
-const path = require('path');
-const cliConfig = require('../config');
-const { getProvider } = require('../utils/cli-session');
-const { SageEchoExecutor } = require('@sage-protocol/sdk');
-
-function readJsonFile(filePath) {
-  const resolved = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
-  const raw = fs.readFileSync(resolved, 'utf8');
-  return JSON.parse(raw);
-}
-
-function buildContext(options) {
-  if (options.contextFile) {
-    return readJsonFile(options.contextFile);
-  }
-  if (options.context) {
-    try {
-      return JSON.parse(options.context);
-    } catch (error) {
-      throw new Error(`Failed to parse --context JSON: ${error.message}`);
-    }
-  }
-  return {};
-}
-
-function resolveRegistry(passed) {
-  if (passed) return passed;
-
-  if (typeof cliConfig.readProfiles === 'function') {
-    const profiles = cliConfig.readProfiles();
-    const active = profiles.activeProfile || 'default';
-    const addresses = profiles.profiles?.[active]?.addresses || {};
-    if (addresses.PROMPT_REGISTRY_ADDRESS) return addresses.PROMPT_REGISTRY_ADDRESS;
-    if (addresses.LIBRARY_REGISTRY_ADDRESS) return addresses.LIBRARY_REGISTRY_ADDRESS;
-  }
-
-  return process.env.PROMPT_REGISTRY_ADDRESS || process.env.LIBRARY_REGISTRY_ADDRESS || null;
-}
-
-function formatResult(result) {
-  if (!result || typeof result !== 'object') return result;
-  const { prompt, response, request } = result;
-  return {
-    prompt,
-    request,
-    response,
-  };
-}
-
-const promptTest = new Command('test')
-  .description('Execute a prompt from the registry via Echo')
-  .argument('<promptKey>', 'Key of the prompt stored in the registry')
-  .option('-r, --registry <address>', 'Prompt registry address (defaults to configured LIBRARY_REGISTRY_ADDRESS)')
-  .option('-g, --gateway <url>', 'IPFS gateway to fetch prompt content', process.env.SAGE_IPFS_GATEWAY)
-  .option('-m, --model <model>', 'Echo model to use (defaults to gpt-4o-mini or $ECHO_MODEL)', process.env.ECHO_MODEL)
-  .option('--user <text>', 'User message to send alongside the prompt template')
-  .option('--temperature <float>', 'Sampling temperature (e.g. 0.2)')
-  .option('--max-tokens <int>', 'Maximum number of tokens to generate')
-  .option('--top-p <float>', 'Top-p nucleus sampling value (0-1)')
-  .option('--context <json>', 'Inline JSON payload passed to the prompt execution context')
-  .option('--context-file <path>', 'Path to JSON file used as execution context')
-  .option('--json', 'Emit raw JSON response only')
-  .action(async (promptKey, options) => {
-    try {
-      if (typeof cliConfig.loadEnv === 'function') {
-        try { cliConfig.loadEnv(); } catch (_) {}
-      }
-
-      // Read-only execution: only a provider is required
-      const provider = await getProvider({ preferWallet: true });
-      const registry = resolveRegistry(options.registry);
-      if (!registry) {
-        throw new Error('Prompt registry address not configured. Provide --registry or import addresses via `sage config addresses import`.');
-      }
-
-      const echoApiKey = process.env.ECHO_API_KEY;
-      const echoAppId = process.env.ECHO_APP_ID || process.env.NEXT_PUBLIC_ECHO_APP_ID;
-
-      if (!echoApiKey) {
-        throw new Error('ECHO_API_KEY is not set. Create an Echo API key in the Echo dashboard and export it before running this command.');
-      }
-
-      const context = buildContext(options);
-
-      if (process.env.SAGE_DEBUG_PROMPT_TEST === '1') {
-        console.log('[debug] context loaded, initializing executor');
-      }
-
-      const executor = new SageEchoExecutor(provider, null, {
-        registry,
-        ipfsGateway: options.gateway,
-        apiKey: echoApiKey,
-        appId: echoAppId,
-        model: options.model,
-        routerUrl: process.env.ECHO_ROUTER_URL,
-      });
-
-      const execOptions = {
-        registry,
-        ipfsGateway: options.gateway,
-        model: options.model,
-        userMessage: options.user,
-      };
-
-      if (typeof options.temperature !== 'undefined') {
-        const temp = Number(options.temperature);
-        if (Number.isNaN(temp)) {
-          throw new Error('Temperature must be a number.');
-        }
-        execOptions.temperature = temp;
-      }
-      if (typeof options.maxTokens !== 'undefined') {
-        const maxTokens = parseInt(options.maxTokens, 10);
-        if (Number.isNaN(maxTokens)) {
-          throw new Error('max-tokens must be an integer.');
-        }
-        execOptions.maxTokens = maxTokens;
-      }
-      if (typeof options.topP !== 'undefined') {
-        const topP = Number(options.topP);
-        if (Number.isNaN(topP)) {
-          throw new Error('top-p must be a number.');
-        }
-        execOptions.topP = topP;
-      }
-
-      const result = await executor.executePrompt(promptKey, context, execOptions);
-
-      if (process.env.SAGE_DEBUG_PROMPT_TEST === '1') {
-        console.log('[debug] execution complete');
-      }
-      const payload = formatResult(result);
-      const { response } = payload;
-      const raw = response?.raw || null;
-      const firstChoice = Array.isArray(raw?.choices) ? raw.choices[0] : null;
-      const completionText =
-        response?.text ||
-        firstChoice?.message?.content ||
-        firstChoice?.text ||
-        null;
-      const usage = response?.usage || raw?.usage || null;
-      const modelUsed = raw?.model || response?.model || execOptions.model || process.env.ECHO_MODEL || 'gpt-4o-mini';
-      const responseId = raw?.id || response?.id || null;
-
-      if (options.json || process.env.SAGE_QUIET_JSON === '1') {
-        console.log(JSON.stringify(payload, null, 2));
-      } else {
-        console.log('✅ Echo prompt execution succeeded');
-        console.log(`Model: ${modelUsed}`);
-        if (usage) {
-          console.log(`Tokens — prompt: ${usage.prompt_tokens ?? 'n/a'}, completion: ${usage.completion_tokens ?? 'n/a'}, total: ${usage.total_tokens ?? 'n/a'}`);
-        }
-        if (responseId) {
-          console.log(`Response ID: ${responseId}`);
-        }
-        if (completionText) {
-          console.log('\n--- Assistant Response ---\n');
-          console.log(completionText);
-          console.log('\n--------------------------');
-        } else {
-          console.log('\n(No assistant message returned — inspect JSON output for details)');
-        }
-      }
-    } catch (error) {
-      if (options.json || process.env.SAGE_QUIET_JSON === '1') {
-        console.error(JSON.stringify({ error: error.message, code: error.code || null }));
-      } else {
-        console.error(`❌ Failed to execute prompt: ${error.message}`);
-      }
-      process.exitCode = 1;
-    }
-  });
-
-module.exports = promptTest;