@feelingmindful/thinking-graph 1.6.0 → 1.8.0

package/dist/index.js

@@ -10,6 +10,7 @@ import { recallSchema, recallHandler } from './tools/recall.js';
 import { learnSchema, learnHandler } from './tools/learn.js';
 import { exportSchema, exportHandler } from './tools/export.js';
 import { researchSchema, researchHandler } from './tools/research.js';
+import { recommendSkillsSchema, recommendSkillsHandler } from './tools/recommend-skills.js';
 // Legacy compat shim removed — use `think` tool directly
 // ─── Storage setup ───────────────────────────────────────
 const memoryOnly = process.env.THINKING_GRAPH_MEMORY_ONLY === 'true';
@@ -32,6 +33,7 @@ server.tool('recall', 'Query the thinking graph — search by text, filter by ty
 server.tool('learn', 'Store durable knowledge — code facts, tech debt, insights, principles. Deduplicates similar content.', learnSchema.shape, async (input) => learnHandler(graph, input));
 server.tool('export', 'Export the thinking graph as JSON or a human-readable markdown summary.', exportSchema.shape, async (input) => exportHandler(graph, input));
 server.tool('research', 'Research a topic using Perplexity/Firecrawl, then ingest findings into the graph. Two-phase: call once to get an action plan, then again with findings to store them.', researchSchema.shape, async (input) => researchHandler(graph, input));
+server.tool('recommend-skills', 'Recommend installed marketplace skills by area, verb, platform, or what they produce/detect. Use during reasoning to find skills that can help with the current task.', recommendSkillsSchema.shape, async (input) => recommendSkillsHandler(graph, input));
 // ─── Startup ─────────────────────────────────────────────
 async function main() {
     await storage.initialize();

package/dist/tools/find-skills.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+export declare const findSkillsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    area: z.ZodOptional<z.ZodString>;
+    verb: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodEnum<["ios", "android", "web", "all"]>>;
+    produces: z.ZodOptional<z.ZodString>;
+    detects: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    verb?: string | undefined;
+    detects?: string | undefined;
+    produces?: string | undefined;
+    platform?: "all" | "web" | "ios" | "android" | undefined;
+    area?: string | undefined;
+    query?: string | undefined;
+}, {
+    verb?: string | undefined;
+    detects?: string | undefined;
+    produces?: string | undefined;
+    platform?: "all" | "web" | "ios" | "android" | undefined;
+    area?: string | undefined;
+    query?: string | undefined;
+}>;
+export type FindSkillsInput = z.infer<typeof findSkillsSchema>;
+export declare function findSkillsHandler(graph: ThinkingGraph, input: FindSkillsInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/find-skills.js

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+export const findSkillsSchema = z.object({
+    query: z.string().optional().describe('Free-text search across skill names, areas, and verbs'),
+    area: z.string().optional().describe('Filter by area (e.g., accessibility, security, monetization, copy, architecture)'),
+    verb: z.string().optional().describe('Filter by action verb (e.g., audit, create, refactor, research)'),
+    platform: z.enum(['ios', 'android', 'web', 'all']).optional().describe('Filter by platform'),
+    produces: z.string().optional().describe('Filter by node type the skill produces (e.g., detection, tech_debt, code_fact, decision)'),
+    detects: z.string().optional().describe('Filter by what the skill detects (e.g., missing, needs-work)'),
+});
+function matchesQuery(skill, query) {
+    const q = query.toLowerCase();
+    return (skill.skillName.toLowerCase().includes(q) ||
+        skill.pluginName.toLowerCase().includes(q) ||
+        (skill.verb?.toLowerCase().includes(q) ?? false) ||
+        skill.areas.some(a => a.toLowerCase().includes(q)) ||
+        skill.detects.some(d => d.toLowerCase().includes(q)) ||
+        skill.produces.some(p => p.toLowerCase().includes(q)));
+}
+export async function findSkillsHandler(graph, input) {
+    // Build filter for structured fields
+    const filter = {};
+    if (input.verb)
+        filter.verb = input.verb;
+    if (input.platform)
+        filter.platform = input.platform;
+    // Query the registry
+    let results = await graph.storage.querySkills(filter);
+    // Apply free-text search
+    if (input.query) {
+        results = results.filter(s => matchesQuery(s, input.query));
+    }
+    // Apply area filter (areas is an array, need partial match)
+    if (input.area) {
+        const area = input.area.toLowerCase();
+        results = results.filter(s => s.areas.some(a => a.toLowerCase().includes(area)));
+    }
+    // Apply produces filter
+    if (input.produces) {
+        const produces = input.produces.toLowerCase();
+        results = results.filter(s => s.produces.some(p => p.toLowerCase().includes(produces)));
+    }
+    // Apply detects filter
+    if (input.detects) {
+        const detects = input.detects.toLowerCase();
+        results = results.filter(s => s.detects.some(d => d.toLowerCase().includes(detects)));
+    }
+    // Format results with invocation commands
+    const skills = results.map(s => ({
+        id: s.id,
+        plugin: s.pluginName,
+        skill: s.skillName,
+        invocation: s.invocation,
+        verb: s.verb,
+        areas: s.areas,
+        detects: s.detects,
+        produces: s.produces,
+        invokes: s.invokes,
+        platform: s.platform,
+    }));
+    // Build suggestions for the agent
+    const suggestions = skills.slice(0, 3).map(s => ({
+        tool: 'skill',
+        when: `Invoke ${s.plugin}:${s.skill} to ${s.verb ?? 'run'} ${s.areas.length > 0 ? `(covers: ${s.areas.join(', ')})` : ''}`,
+        example: { skill: `${s.plugin}:${s.skill}` },
+    }));
+    // If skills produce node types, suggest piping results back via learn
+    if (skills.some(s => s.produces.length > 0)) {
+        suggestions.push({
+            tool: 'learn',
+            when: 'After invoking a skill, store its key findings back in the graph',
+            example: { skill: 'learn', content: '<skill findings>', type: 'skill_result' },
+        });
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    matchCount: skills.length,
+                    skills,
+                    ...(suggestions.length > 0 && { suggestions }),
+                }),
+            }],
+    };
+}

package/dist/tools/recommend-skills.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { ThinkingGraph } from '../engine/graph.js';
+export declare const recommendSkillsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    area: z.ZodOptional<z.ZodString>;
+    verb: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodEnum<["ios", "android", "web", "all"]>>;
+    produces: z.ZodOptional<z.ZodString>;
+    detects: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    verb?: string | undefined;
+    detects?: string | undefined;
+    produces?: string | undefined;
+    platform?: "all" | "web" | "ios" | "android" | undefined;
+    area?: string | undefined;
+    query?: string | undefined;
+}, {
+    verb?: string | undefined;
+    detects?: string | undefined;
+    produces?: string | undefined;
+    platform?: "all" | "web" | "ios" | "android" | undefined;
+    area?: string | undefined;
+    query?: string | undefined;
+}>;
+export type RecommendSkillsInput = z.infer<typeof recommendSkillsSchema>;
+export declare function recommendSkillsHandler(graph: ThinkingGraph, input: RecommendSkillsInput): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/recommend-skills.js

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+export const recommendSkillsSchema = z.object({
+    query: z.string().optional().describe('Free-text search across skill names, areas, and verbs'),
+    area: z.string().optional().describe('Filter by area (e.g., accessibility, security, monetization, copy, architecture)'),
+    verb: z.string().optional().describe('Filter by action verb (e.g., audit, create, refactor, research)'),
+    platform: z.enum(['ios', 'android', 'web', 'all']).optional().describe('Filter by platform'),
+    produces: z.string().optional().describe('Filter by node type the skill produces (e.g., detection, tech_debt, code_fact, decision)'),
+    detects: z.string().optional().describe('Filter by what the skill detects (e.g., missing, needs-work)'),
+});
+function matchesQuery(skill, query) {
+    const q = query.toLowerCase();
+    return (skill.skillName.toLowerCase().includes(q) ||
+        skill.pluginName.toLowerCase().includes(q) ||
+        (skill.verb?.toLowerCase().includes(q) ?? false) ||
+        skill.areas.some(a => a.toLowerCase().includes(q)) ||
+        skill.detects.some(d => d.toLowerCase().includes(q)) ||
+        skill.produces.some(p => p.toLowerCase().includes(q)));
+}
+export async function recommendSkillsHandler(graph, input) {
+    // Build filter for structured fields
+    const filter = {};
+    if (input.verb)
+        filter.verb = input.verb;
+    if (input.platform)
+        filter.platform = input.platform;
+    // Query the registry
+    let results = await graph.storage.querySkills(filter);
+    // Apply free-text search
+    if (input.query) {
+        results = results.filter(s => matchesQuery(s, input.query));
+    }
+    // Apply area filter (areas is an array, need partial match)
+    if (input.area) {
+        const area = input.area.toLowerCase();
+        results = results.filter(s => s.areas.some(a => a.toLowerCase().includes(area)));
+    }
+    // Apply produces filter
+    if (input.produces) {
+        const produces = input.produces.toLowerCase();
+        results = results.filter(s => s.produces.some(p => p.toLowerCase().includes(produces)));
+    }
+    // Apply detects filter
+    if (input.detects) {
+        const detects = input.detects.toLowerCase();
+        results = results.filter(s => s.detects.some(d => d.toLowerCase().includes(detects)));
+    }
+    // Format results with invocation commands
+    const skills = results.map(s => ({
+        id: s.id,
+        plugin: s.pluginName,
+        skill: s.skillName,
+        invocation: s.invocation,
+        verb: s.verb,
+        areas: s.areas,
+        detects: s.detects,
+        produces: s.produces,
+        invokes: s.invokes,
+        platform: s.platform,
+    }));
+    // Build suggestions for the agent
+    const suggestions = skills.slice(0, 3).map(s => ({
+        tool: 'skill',
+        when: `Invoke ${s.plugin}:${s.skill} to ${s.verb ?? 'run'} ${s.areas.length > 0 ? `(covers: ${s.areas.join(', ')})` : ''}`,
+        example: { skill: `${s.plugin}:${s.skill}` },
+    }));
+    // If skills produce node types, suggest piping results back via learn
+    if (skills.some(s => s.produces.length > 0)) {
+        suggestions.push({
+            tool: 'learn',
+            when: 'After invoking a skill, store its key findings back in the graph',
+            example: { skill: 'learn', content: '<skill findings>', type: 'skill_result' },
+        });
+    }
+    // If no local matches, suggest external skill discovery
+    if (skills.length === 0) {
+        const searchQuery = input.query ?? input.area ?? input.verb ?? '';
+        suggestions.push({
+            tool: 'skill',
+            when: 'No installed skills match — search the marketplace for skills to install',
+            example: { skill: 'find-skills', args: searchQuery },
+        });
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    matchCount: skills.length,
+                    skills,
+                    ...(suggestions.length > 0 && { suggestions }),
+                }),
+            }],
+    };
+}

package/dist/tools/think.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { NODE_TYPES, EDGE_TYPES, GLOBAL_NODE_TYPES } from '../engine/types.js';
 const coerceBool = z.preprocess((v) => (v === 'true' ? true : v === 'false' ? false : v), z.boolean());
-function buildSuggestions(type, thoughtNumber, relatedCount, stats) {
+function buildSuggestions(type, thoughtNumber, relatedCount, stats, matchedSkills) {
     const suggestions = [];
     // First thought in session — suggest recall to check prior knowledge
     if (thoughtNumber === 1 && stats.totalNodes > 1) {
@@ -80,6 +80,10 @@ function buildSuggestions(type, thoughtNumber, relatedCount, stats) {
             example: { skill: 'premium-core:reasoning' },
         });
     }
+    // Append matched skills from the registry
+    if (matchedSkills && matchedSkills.length > 0) {
+        suggestions.push(...matchedSkills);
+    }
     return suggestions;
 }
 export const thinkSchema = z.object({
@@ -134,7 +138,24 @@ export async function thinkHandler(graph, input) {
         }
     }
     const stats = await graph.storage.getStats();
-    const suggestions = buildSuggestions(input.type ?? 'thought', input.thoughtNumber, relatedCount, stats);
+    // Query skill registry for relevant skills when detection/tech_debt nodes are created
+    let matchedSkills;
+    const nodeType = input.type ?? 'thought';
+    if (nodeType === 'detection' || nodeType === 'tech_debt' || nodeType === 'code_fact') {
+        const allSkills = await graph.storage.querySkills({});
+        const content = input.thought.toLowerCase();
+        // Match skills whose areas overlap with the thought content
+        const matches = allSkills.filter(s => s.areas.some(area => content.includes(area.toLowerCase())) ||
+            (s.verb && content.includes(s.verb.toLowerCase())));
+        if (matches.length > 0) {
+            matchedSkills = matches.slice(0, 2).map(s => ({
+                tool: 'skill',
+                when: `${s.verb ?? 'Run'} with ${s.pluginName}:${s.skillName} (covers: ${s.areas.join(', ')})`,
+                example: { skill: `${s.pluginName}:${s.skillName}` },
+            }));
+        }
+    }
+    const suggestions = buildSuggestions(nodeType, input.thoughtNumber, relatedCount, stats, matchedSkills);
     return {
         content: [{
                 type: 'text',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feelingmindful/thinking-graph",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
   "type": "module",
   "main": "dist/index.js",