@feelingmindful/thinking-graph 1.5.0 → 1.7.0

package/dist/engine/graph.js

@@ -241,6 +241,50 @@ export class ThinkingGraph {
         if (stats.principleViolations > 0) {
             lines.push(`## Principle Violations: ${stats.principleViolations}`);
         }
+        // Session utilization — show which tool capabilities were exercised
+        const nodeTypes = stats.nodesByType;
+        const edgeTypes = stats.edgesByType;
+        const totalEdges = stats.totalEdges;
+        // Count user-created nodes (exclude pre-seeded principles and skill_result)
+        const thinkUsed = (nodeTypes.thought ?? 0) + (nodeTypes.decision ?? 0) +
+            (nodeTypes.assumption ?? 0) + (nodeTypes.detection ?? 0) +
+            (nodeTypes.tech_debt ?? 0) + (nodeTypes.code_fact ?? 0) > 0;
+        const relateUsed = totalEdges > 0;
+        const learnUsed = (nodeTypes.insight ?? 0) + (nodeTypes.pattern ?? 0) > 0;
+        const researchUsed = (nodeTypes.research ?? 0) > 0;
+        const tools = [
+            { name: 'think', used: thinkUsed, purpose: 'record reasoning steps' },
+            { name: 'relate', used: relateUsed, purpose: 'connect nodes with typed edges' },
+            { name: 'recall', used: null, purpose: 'query prior knowledge (not trackable)' },
+            { name: 'learn', used: learnUsed, purpose: 'persist insights cross-project' },
+            { name: 'research', used: researchUsed, purpose: 'web research via Perplexity/Firecrawl' },
+        ];
+        lines.push('', '## Tool Utilization');
+        for (const t of tools) {
+            if (t.used === null) {
+                lines.push(`- ${t.name}: ~ (${t.purpose})`);
+            }
+            else {
+                lines.push(`- ${t.name}: ${t.used ? '✓' : '✗ unused'} (${t.purpose})`);
+            }
+        }
+        // Flag underutilization
+        const warnings = [];
+        if (thinkUsed && !relateUsed) {
+            warnings.push('Thoughts are unconnected — use `relate` to link dependencies, contradictions, and supporting evidence');
+        }
+        if (thinkUsed && !learnUsed) {
+            warnings.push('No insights persisted — use `learn` to save conclusions that should carry to future sessions');
+        }
+        if ((nodeTypes.assumption ?? 0) > 0 && !researchUsed) {
+            warnings.push('Assumptions recorded but not verified — use `research` to fact-check before building on them');
+        }
+        if (warnings.length > 0) {
+            lines.push('', '## Underutilization Warnings');
+            for (const w of warnings) {
+                lines.push(`- ⚠ ${w}`);
+            }
+        }
         return lines.join('\n');
     }
     // ─── Seeding ──────────────────────────────────────────

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,84 @@
+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' },
+        });
+    }
+    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) {
@@ -72,6 +72,18 @@ function buildSuggestions(type, thoughtNumber, relatedCount, stats) {
             example: { sourceId: '<this nodeId>', targetId: '?<search term>', type: 'supports' },
         });
     }
+    // If the agent is think-only (no relates, early in session), nudge toward the reasoning skill
+    if (relatedCount === 0 && thoughtNumber <= 2 && stats.totalEdges === 0 && stats.totalNodes > 1) {
+        suggestions.push({
+            tool: 'skill',
+            when: 'Load the reasoning skill for structured thinking: recall → think → relate → research → decide → learn',
+            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({
@@ -126,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.5.0",
+  "version": "1.7.0",
   "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/feeling-mindful/feeling-mindful-plugins.git",
-    "directory": "plugins/premium-core/mcp-servers/thinking-graph"
+    "directory": "packages/thinking-graph"
   },
   "publishConfig": {
     "access": "public",