@sage-protocol/cli 0.3.2 → 0.3.3

package/dist/cli/mcp-server-stdio.js

@@ -593,6 +593,72 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
           required: ['manifest']
         }
       },
+      {
+        name: 'list_templates',
+        description: 'List available prompt templates for quick creation.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            category: { type: 'string', description: 'Optional category filter (design, development, analysis, etc.)' },
+            search: { type: 'string', description: 'Optional text search over template key/name/description' }
+          },
+          required: []
+        }
+      },
+      {
+        name: 'get_template',
+        description: 'Get detailed information about a specific prompt template.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            key: { type: 'string', description: 'Template key' }
+          },
+          required: ['key']
+        }
+      },
+      {
+        name: 'create_from_template',
+        description: 'Create a new prompt from a template and save it into a local library via quick_create_prompt.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            template: { type: 'string', description: 'Template key' },
+            customize: {
+              type: 'object',
+              description: 'Values to substitute into the template variables'
+            },
+            library: {
+              type: 'string',
+              description: 'Target library name or CID (optional, default: My Library)'
+            },
+            name: {
+              type: 'string',
+              description: 'Override prompt display name (optional)'
+            }
+          },
+          required: ['template', 'customize']
+        }
+      },
+      {
+        name: 'analyze_dependencies',
+        description: 'Analyze variable usage across all prompts in a pinned library.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            library: {
+              type: 'string',
+              description: 'Pinned library name or CID'
+            },
+            analysis_type: {
+              type: 'string',
+              enum: ['variables', 'all'],
+              description: 'Type of analysis (v1 supports variables)',
+              default: 'variables'
+            }
+          },
+          required: ['library']
+        }
+      },
       {
         name: 'update_library_metadata',
         description: 'Update library-level metadata (name/description/tags) and optionally propagate tags to prompts.',
@@ -670,74 +736,33 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
         }
       },
       {
-        name: 'list_templates',
-        description: 'List available prompt templates for quick creation.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            category: { type: 'string', description: 'Optional category filter (design, development, analysis, etc.)' },
-            search: { type: 'string', description: 'Optional text search over template key/name/description' }
-          },
-          required: []
-        }
-      },
-      {
-        name: 'get_template',
-        description: 'Get detailed information about a specific prompt template.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            key: { type: 'string', description: 'Template key' }
-          },
-          required: ['key']
-        }
-      },
-      {
-        name: 'create_from_template',
-        description: 'Create a new prompt from a template and save it into a local library via quick_create_prompt.',
+        name: 'suggest_subdaos_for_library',
+        description: 'Suggest SubDAOs that might be a good fit for publishing a given local library, and provide CLI workflows for creating your own SubDAO and pushing the library.',
         inputSchema: {
           type: 'object',
           properties: {
-            template: { type: 'string', description: 'Template key' },
-            customize: {
-              type: 'object',
-              description: 'Values to substitute into the template variables'
-            },
             library: {
               type: 'string',
-              description: 'Target library name or CID (optional, default: My Library)'
+              description: 'Local pinned library name or CID'
             },
-            name: {
-              type: 'string',
-              description: 'Override prompt display name (optional)'
-            }
-          },
-          required: ['template', 'customize']
-        }
-      },
-      {
-        name: 'analyze_dependencies',
-        description: 'Analyze variable usage across all prompts in a pinned library.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            library: {
-              type: 'string',
-              description: 'Pinned library name or CID'
+            limit: {
+              type: 'number',
+              description: 'Max SubDAOs to return (default 5)',
+              default: 5
             },
-            analysis_type: {
+            mode_filter: {
               type: 'string',
-              enum: ['variables', 'all'],
-              description: 'Type of analysis (v1 supports variables)',
-              default: 'variables'
+              enum: ['any', 'creator', 'squad', 'community'],
+              description: 'Optional governance mode preference',
+              default: 'any'
             }
           },
           required: ['library']
         }
       },
       {
-        name: 'suggest_subdaos_for_library',
-        description: 'Suggest SubDAOs that might be a good fit for publishing a given local library, and provide CLI workflows for creating your own SubDAO and pushing the library.',
+        name: 'generate_publishing_commands',
+        description: 'Generate ready-to-run CLI commands for validating, uploading, and proposing a library manifest on-chain.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -745,16 +770,10 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
               type: 'string',
               description: 'Local pinned library name or CID'
             },
-            limit: {
-              type: 'number',
-              description: 'Max SubDAOs to return (default 5)',
-              default: 5
-            },
-            mode_filter: {
+            target: {
               type: 'string',
-              enum: ['any', 'creator', 'squad', 'community'],
-              description: 'Optional governance mode preference',
-              default: 'any'
+              description: 'Target SubDAO address or "auto" to pick a likely candidate',
+              default: 'auto'
             }
           },
           required: ['library']
@@ -1015,6 +1034,7 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       'tool:create_from_template': (params) => this.createPromptFromTemplate(params),
       'tool:analyze_dependencies': (params) => this.analyzeDependencies(params),
       'tool:suggest_subdaos_for_library': (params) => this.suggestSubdaosForLibrary(params),
+      'tool:generate_publishing_commands': (params) => this.generatePublishingCommands(params),
     });
 
     const toolHandlers = {
@@ -1048,6 +1068,50 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
     return this.libraryBindingsManager.buildBindingsForSubdao(subdaoAddr);
   }
 
+  async _enrichSubdaos(subdaos) {
+    return Promise.all(subdaos.map(async (s) => {
+      const derivedTags = new Set();
+      let libraryCount = 0;
+
+      try {
+        const libraries = await this.libraryBindingsManager.buildBindingsForSubdao(s.address);
+        libraryCount = libraries.length;
+
+        // Check up to 3 libraries per SubDAO to gather context
+        for (const lib of libraries.slice(0, 3)) {
+          try {
+            const registry = new ethers.Contract(lib.registry, this.libraryRegistryAbi, this.provider);
+            const count = await registry.getManifestCIDCount();
+            if (count > 0) {
+              const cid = await registry.getManifestCID(count - 1n);
+              if (cid) {
+                const { manifest } = await this.manifestFetcher.fetchManifest(cid);
+                if (manifest?.library?.tags) {
+                  manifest.library.tags.forEach(t => derivedTags.add(String(t).toLowerCase().trim()));
+                }
+                if (manifest?.prompts) {
+                  manifest.prompts.forEach(p => {
+                    if (p.tags) p.tags.forEach(t => derivedTags.add(String(t).toLowerCase().trim()));
+                  });
+                }
+              }
+            }
+          } catch (e) {
+            // ignore individual library fetch errors
+          }
+        }
+      } catch (e) {
+        // ignore binding fetch errors
+      }
+
+      return {
+        ...s,
+        derivedTags: Array.from(derivedTags),
+        libraryCount
+      };
+    }));
+  }
+
 
   // ───────────────────────────── MCP Prompts helpers ─────────────────────────────
   getDiscoveryClient() {
@@ -1671,7 +1735,8 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       }
       const libTags = Array.from(tagsSet);
 
-      const subdaos = await this.getSubDAOList({ limit: 50 });
+      // Fetch candidates - limit to 20 to allow for deeper analysis
+      const subdaos = await this.getSubDAOList({ limit: 20 });
       if (!subdaos || !subdaos.length) {
         const fallbackText =
           'No SubDAOs discovered from subgraph/factory.\n\n' +
@@ -1686,9 +1751,12 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
         return { content: [{ type: 'text', text: fallbackText }] };
       }
 
+      // Enrich SubDAOs with tags from their attached libraries
+      const enrichedSubdaos = await this._enrichSubdaos(subdaos);
+
       const modeFilter = mode_filter || 'any';
       const scored = [];
-      for (const s of subdaos) {
+      for (const s of enrichedSubdaos) {
         const name = String(s.name || '').toLowerCase();
         const desc = String(s.description || '').toLowerCase();
         const tokens = new Set(
@@ -1697,6 +1765,10 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
             .map((t) => t.toLowerCase().trim())
             .filter(Boolean),
         );
+
+        // Add derived tags to tokens for matching
+        s.derivedTags.forEach(t => tokens.add(t));
+
         let matchCount = 0;
         const matchedTags = [];
         for (const tag of libTags) {
@@ -1710,20 +1782,22 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
           // Mode-specific filtering can be added in a future iteration.
         }
 
-        const libraryCount = Array.isArray(s.registries) ? s.registries.length : 0;
-        const fitScore = matchCount + libraryCount * 0.1;
+        // Boost score if we matched on derived tags (stronger signal than just name)
+        const fitScore = matchCount + s.libraryCount * 0.1;
         scored.push({
           address: s.address,
           name: s.name || `SubDAO-${String(s.address).slice(-6)}`,
           description: s.description || '',
           registryAddress: s.registryAddress || null,
           defaultLibraryId: s.defaultLibraryId || 'main',
-          libraryCount,
+          libraryCount: s.libraryCount,
           matchedTags,
           fitScore,
+          derivedTags: s.derivedTags // Include for debugging/info
         });
       }
 
+      const anyTagMatches = scored.some((s) => (s.matchedTags || []).length > 0);
       scored.sort((a, b) => (b.fitScore || 0) - (a.fitScore || 0));
       const top = scored.slice(0, limit);
 
@@ -1731,14 +1805,32 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       lines.push(`🎯 Suggested SubDAOs for library "${libName}"`);
       lines.push('');
 
-      if (!top.length || !libTags.length) {
+      if (!top.length || !libTags.length || !anyTagMatches) {
         lines.push('No strong SubDAO matches found based on tags and names.');
+        if (top.length) {
+          lines.push('');
+          lines.push('Here are some recent SubDAOs you may consider, but scoring is neutral:');
+          lines.push('');
+          top.forEach((s, idx) => {
+            lines.push(`${idx + 1}. ${s.name} (${s.address})`);
+            lines.push(`   • Libraries: ${s.libraryCount}`);
+            if (s.description) {
+              lines.push(`   • Description: ${s.description}`);
+            }
+            lines.push('');
+          });
+        }
       } else {
         top.forEach((s, idx) => {
           lines.push(`${idx + 1}. ${s.name} (${s.address})`);
           if (s.matchedTags.length) {
             lines.push(`   • Tag overlap: ${s.matchedTags.join(', ')}`);
           }
+          if (s.derivedTags.length > 0) {
+            // Show a few derived tags to explain why it matched
+            const displayTags = s.derivedTags.slice(0, 5).join(', ');
+            lines.push(`   • Context: ${displayTags}${s.derivedTags.length > 5 ? '...' : ''}`);
+          }
           lines.push(`   • Libraries: ${s.libraryCount}`);
           if (s.description) {
             lines.push(`   • Description: ${s.description}`);
@@ -1814,6 +1906,178 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
     }
   }
 
+  async generatePublishingCommands({ library, target = 'auto' } = {}) {
+    try {
+      const lm = this.libraryManager;
+      const pinned = lm.listPinned() || [];
+      const id = String(library || '').trim();
+      if (!id) {
+        return { content: [{ type: 'text', text: 'Error: library parameter is required' }] };
+      }
+
+      let selected = null;
+      let row = pinned.find((r) => r.cid === id);
+      if (row) {
+        selected = lm.loadPinned(row.cid);
+        selected.row = row;
+      } else {
+        const lower = id.toLowerCase();
+        const matches = [];
+        for (const r of pinned) {
+          try {
+            const loaded = lm.loadPinned(r.cid);
+            const libName = String(loaded.manifest?.library?.name || r.name || '').toLowerCase();
+            if (libName === lower) {
+              matches.push({ row: r, ...loaded });
+            }
+          } catch (_) {
+            // ignore corrupt
+          }
+        }
+        if (matches.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `No pinned library found matching "${library}". Use list_libraries(source="local") to see available libraries.`,
+              },
+            ],
+          };
+        }
+        if (matches.length > 1) {
+          const lines = matches.map(
+            (m) => `- ${m.row.cid} (${m.manifest?.library?.name || m.row.name || 'unnamed'})`,
+          );
+          return {
+            content: [
+              {
+                type: 'text',
+                text:
+                  `Ambiguous library match for "${library}". Candidates:\n` +
+                  `${lines.join('\n')}\n\nPass an explicit CID to disambiguate.`,
+              },
+            ],
+          };
+        }
+        selected = matches[0];
+      }
+
+      const manifest = selected.manifest;
+      const manifestPath = selected.path;
+      const libName = manifest.library?.name || selected.row?.name || library;
+      const libDescription = manifest.library?.description || '';
+
+      let chosenSubdao = '';
+      let subdaoReason = '';
+      if (target && target !== 'auto') {
+        chosenSubdao = target;
+        subdaoReason = 'Target provided explicitly.';
+      } else {
+        const tagsSet = new Set(
+          (manifest.library?.tags || []).map((t) => String(t).toLowerCase().trim()).filter(Boolean),
+        );
+        for (const p of manifest.prompts || []) {
+          if (!p || !Array.isArray(p.tags)) continue;
+          for (const t of p.tags) {
+            const v = String(t).toLowerCase().trim();
+            if (v) tagsSet.add(v);
+          }
+        }
+        const libTags = Array.from(tagsSet);
+
+        const subdaos = await this.getSubDAOList({ limit: 20 });
+        if (subdaos && subdaos.length && libTags.length) {
+          const enrichedSubdaos = await this._enrichSubdaos(subdaos);
+          const scored = enrichedSubdaos.map((s) => {
+            const name = String(s.name || '').toLowerCase();
+            const desc = String(s.description || '').toLowerCase();
+            const tokens = new Set(
+              (name + ' ' + desc)
+                .split(/[^a-z0-9]+/i)
+                .map((t) => t.toLowerCase().trim())
+                .filter(Boolean),
+            );
+            s.derivedTags.forEach(t => tokens.add(t));
+
+            let matchCount = 0;
+            for (const tag of libTags) {
+              if (tokens.has(tag)) matchCount += 1;
+            }
+            const fitScore = matchCount + s.libraryCount * 0.1;
+            return { subdao: s, fitScore, matchCount, libraryCount: s.libraryCount };
+          });
+          // Only auto-pick if there is at least one SubDAO with tag matches
+          const withMatches = scored.filter((s) => s.matchCount > 0);
+          if (withMatches.length) {
+            withMatches.sort((a, b) => (b.fitScore || 0) - (a.fitScore || 0));
+            const top = withMatches[0];
+            if (top && top.subdao) {
+              chosenSubdao = top.subdao.address;
+              subdaoReason = `Auto-selected based on tag/name overlap and existing libraries (${top.matchCount} matching tag(s)).`;
+            }
+          }
+        }
+      }
+
+      const manifestPathHint = manifestPath || `~/.sage/libraries/${selected.row.cid}.json`;
+      const inspectCmd = `sage library cache view ${selected.row.cid}`;
+      const pushCmd = chosenSubdao
+        ? `sage library push ${manifestPathHint} --subdao ${chosenSubdao} --pin --wait`
+        : `sage library push ${manifestPathHint} --subdao 0xYourSubDAO --pin --wait`;
+      const proposalsCmd = chosenSubdao
+        ? `sage governance proposals --subdao ${chosenSubdao}`
+        : 'sage governance proposals --subdao 0xYourSubDAO';
+
+      const lines = [];
+      lines.push(`📦 Publishing Guide for "${libName}"`);
+      lines.push('');
+      lines.push(`Manifest CID (local cache): ${selected.row.cid}`);
+      lines.push(`Manifest path: ${manifestPathHint}`);
+      if (chosenSubdao) {
+        lines.push(`Target SubDAO: ${chosenSubdao}`);
+      } else {
+        lines.push('Target SubDAO: (not auto-detected; you must choose an address)');
+      }
+      if (subdaoReason) {
+        lines.push(`Reason: ${subdaoReason}`);
+      }
+      lines.push('');
+      lines.push('Step 1: Inspect manifest (optional)');
+      lines.push(`   ${inspectCmd}`);
+      lines.push('');
+      lines.push('Step 2: Upload manifest and schedule/propose update');
+      lines.push(`   ${pushCmd}`);
+      lines.push('');
+      lines.push('Step 3: Governance follow-up');
+      lines.push(`   ${proposalsCmd}`);
+
+      const payload = {
+        library: {
+          cid: selected.row.cid,
+          name: libName,
+          description: libDescription,
+        },
+        targetSubdao: chosenSubdao || null,
+        steps: [
+          { step: 1, title: 'Inspect manifest', command: inspectCmd },
+          { step: 2, title: 'Upload & propose', command: pushCmd },
+        ],
+        extra: {
+          governanceCommands: [proposalsCmd],
+        },
+      };
+
+      return {
+        content: [
+          { type: 'text', text: lines.join('\n') },
+          { type: 'text', text: '```json\n' + JSON.stringify(payload, null, 2) + '\n```' },
+        ],
+      };
+    } catch (error) {
+      return { content: [{ type: 'text', text: `Error generating publishing commands: ${error.message}` }] };
+    }
+  }
+
   async improvePrompt({ key, library = '', pass = 'single', focus = 'all' } = {}) {
     try {
       if (!key) {
@@ -2088,8 +2352,9 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
       publish: `
 **Publishing Prompts**
 1. Ensure your prompts are ready in a local library.
-2. Use \`publish_manifest_flow\` to pin to IPFS and propose to a SubDAO.
-3. This makes them available on-chain for others to discover.
+2. Use \`publish_manifest_flow\` to validate and build a governance payload.
+3. When ready, use \`generate_publishing_commands(library=\"...\")\` to get copy-paste CLI commands for \`sage library push\` and proposal follow-up.
+4. This makes them available on-chain for others to discover.
 `,
       versioning: `
 **Versioning**
@@ -2097,6 +2362,22 @@ Note: This tool does NOT sign transactions. It prepares everything so you can ex
 - Prompts are stored as files in \`~/.sage/libraries/prompts/\`, so you can use Git for version control.
  - The \`key\` is a stable identifier used to reference the prompt; \`name\` is the human-readable display name.
  - Use \`rename_prompt(key="old", newKey="new", name="New Name")\` when you truly need to change the key; otherwise, prefer updating \`name\` only.
+`,
+      improve: `
+**Improve Prompt**
+- \`improve_prompt\` analyzes an existing prompt and returns advisory output only. It does not modify files.
+- Parameters:
+  - \`key\`: prompt key (required)
+  - \`library\`: optional library name or CID for disambiguation
+  - \`pass\` or \`depth\`: "single" (default) or "deep"
+  - \`focus\`: "variables" | "edge-cases" | "output-quality" | "reusability" | "all"
+
+Behavior:
+- \`pass="single"\`: light structural checks + suggested improvement areas + generic interview questions.
+- \`pass="deep"\`: adds heuristic per-dimension scores (structure, variables, edge cases, reusability) plus richer questions.
+
+Not implemented (advisory only):
+- There is currently **no** \`auto_apply\` or \`compare_to\` behavior. Use \`improve_prompt\` to design changes, then apply them via \`quick_iterate_prompt\` or \`bulk_update_prompts\`.
 `,
       manifest: `
 **Manifest Structure (v2)**

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

@@ -73,9 +73,15 @@ function createToolArgsValidator({ zodModule } = {}) {
     improve_prompt: Z.object({
       key: Z.string().min(1).max(200),
       library: Z.string().min(1).max(200).optional(),
-      pass: Z.enum(['single', 'deep']).optional().default('single'),
+      pass: Z.enum(['single', 'deep']).optional(),
+      depth: Z.enum(['single', 'deep']).optional(),
       focus: Z.enum(['variables', 'edge-cases', 'output-quality', 'reusability', 'all']).optional().default('all'),
-    }),
+    }).transform((obj) => ({
+      key: obj.key,
+      library: obj.library,
+      pass: obj.depth || obj.pass || 'single',
+      focus: obj.focus,
+    })),
     rename_prompt: Z.object({
       key: Z.string().min(1).max(200),
       newKey: Z.string().min(1).max(200).optional(),
@@ -125,6 +131,10 @@ function createToolArgsValidator({ zodModule } = {}) {
       limit: Z.number().int().min(1).max(20).optional().default(5),
       mode_filter: Z.enum(['any', 'creator', 'squad', 'community']).optional().default('any'),
     }),
+    generate_publishing_commands: Z.object({
+      library: Z.string().min(1).max(200),
+      target: Z.string().max(200).optional().default('auto'),
+    }),
   };
 
   return function validate(name, args) {

package/package.json

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