@feelingmindful/thinking-graph 1.15.0 → 1.15.2

package/dist/engine/graph.js

@@ -257,7 +257,7 @@ export class ThinkingGraph {
             { 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' },
+            { name: 'research', used: researchUsed, purpose: 'web research via parallel-cli' },
         ];
         lines.push('', '## Tool Utilization');
         for (const t of tools) {

package/dist/index.js

@@ -56,7 +56,7 @@ server.tool('relate', 'Create a typed, directional relationship between two node
 server.tool('recall', 'Query the thinking graph and Obsidian vault — search by text, filter by type, traverse relationships, or search across projects.', recallSchema.shape, async (input) => recallHandler(graph, input, vault, projectSlug));
 server.tool('learn', 'Store durable knowledge — code facts, tech debt, insights, principles. Writes to both SQLite graph and Obsidian vault.', learnSchema.shape, async (input) => learnHandler(graph, input, vault, projectSlug));
 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 and Obsidian vault. Two-phase: call once to get an action plan, then again with findings to store them.', researchSchema.shape, async (input) => researchHandler(graph, input, vault, projectSlug));
+server.tool('research', 'Research a topic using parallel-cli, then ingest findings into the graph and Obsidian vault. Two-phase: call once to get an action plan, then again with findings to store them.', researchSchema.shape, async (input) => researchHandler(graph, input, vault, projectSlug));
 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));
 server.tool('route-skills', 'Shortlist and rank installed skills for a task using routing heuristics based on platform, verb, areas, detections, and graph context.', routeSkillsSchema.shape, async (input) => routeSkillsHandler(graph, input));
 server.tool('plan-skills', 'Convert a request into an ordered skill execution plan with explicit approval gates before execution. This tool plans but does not execute skills.', planSkillsSchema.shape, async (input) => planSkillsHandler(graph, input));

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

@@ -13,7 +13,7 @@ export declare const planSkillsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     request: string;
     areas?: string[] | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     currentState?: "unknown" | "new" | "existing" | undefined;
     goalVerb?: string | undefined;
     detectedNeeds?: string[] | undefined;
@@ -23,7 +23,7 @@ export declare const planSkillsSchema: z.ZodObject<{
 }, {
     request: string;
     areas?: string[] | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     currentState?: "unknown" | "new" | "existing" | undefined;
     goalVerb?: string | undefined;
     detectedNeeds?: string[] | undefined;

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

@@ -11,14 +11,14 @@ export declare const recommendSkillsSchema: z.ZodObject<{
     verb?: string | undefined;
     detects?: string | undefined;
     produces?: string | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     area?: string | undefined;
     query?: string | undefined;
 }, {
     verb?: string | undefined;
     detects?: string | undefined;
     produces?: string | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     area?: string | undefined;
     query?: string | undefined;
 }>;

package/dist/tools/research.js

@@ -27,12 +27,56 @@ export const researchSchema = z.object({
     findings: z.array(findingSchema).optional().describe('Results to store (phase 2)'),
     // Options
     projectId: z.string().optional(),
-    scrapeUrls: z.array(z.string()).optional().describe('Specific URLs to scrape with Firecrawl'),
+    scrapeUrls: z.array(z.string()).optional().describe('Specific URLs to extract with `parallel-cli extract`'),
     recencyFilter: z.enum(['hour', 'day', 'week', 'month', 'year']).optional().describe('How recent results should be'),
     domainFilter: z.array(z.string()).optional().describe('Restrict to these domains'),
     notebookId: z.string().optional().describe('Specific NotebookLM notebook ID to query. If omitted, action plan will list notebooks first so the caller can pick the best match.'),
     skipGrounded: coerceBool.optional().describe('Skip NotebookLM step even when it would normally auto-prepend'),
 });
+// parallel-cli is a shell CLI (run via Bash), not an MCP. Every research/scrape
+// step shells out to `parallel-cli`. Recency filters map to `--after-date`.
+const RECENCY_TO_DAYS = {
+    hour: 1,
+    day: 1,
+    week: 7,
+    month: 30,
+    year: 365,
+};
+function afterDateFor(recency) {
+    if (!recency)
+        return undefined;
+    const days = RECENCY_TO_DAYS[recency];
+    if (!days)
+        return undefined;
+    const d = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+    return d.toISOString().slice(0, 10); // YYYY-MM-DD
+}
+// Shell-quote a single argument so queries with spaces/quotes stay intact.
+function shq(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function searchFlags(input, recencyDefault) {
+    const flags = [];
+    const afterDate = afterDateFor(input.recencyFilter ?? recencyDefault);
+    if (afterDate)
+        flags.push(`--after-date ${afterDate}`);
+    if (input.domainFilter?.length) {
+        flags.push(`--include-domains ${input.domainFilter.map(shq).join(',')}`);
+    }
+    return flags.length ? ` ${flags.join(' ')}` : '';
+}
+// `parallel-cli research run` has no recency/domain flags (unlike `search`), so
+// fold those constraints into the prompt text to avoid silently dropping them.
+function withResearchConstraints(query, input) {
+    const parts = [];
+    const afterDate = afterDateFor(input.recencyFilter);
+    if (afterDate)
+        parts.push(`Only use sources published on or after ${afterDate}.`);
+    if (input.domainFilter?.length) {
+        parts.push(`Restrict sources to these domains: ${input.domainFilter.join(', ')}.`);
+    }
+    return parts.length ? `${query} ${parts.join(' ')}` : query;
+}
 function buildGroundedSteps(input) {
     const steps = [];
     const query = input.query;
@@ -71,94 +115,86 @@ function buildActionPlan(input) {
     if (shouldPrependGrounded) {
         steps.push(...buildGroundedSteps(input));
     }
-    // grounded_qa is NotebookLM-only — no web fallback steps.
+    // grounded_qa prefers NotebookLM, but must still work when NotebookLM isn't
+    // installed or has no matching notebook — append a web-grounded fallback.
     if (input.intent === 'grounded_qa') {
+        steps.push({
+            tool: 'Bash',
+            description: 'Fallback (use only if NotebookLM is unavailable or returned no matching notebook): cited answer via parallel-cli research run',
+            args: {
+                command: `parallel-cli research run --text ${shq(withResearchConstraints(query, input))} --processor pro -o .premium/research/research-grounded`,
+            },
+        });
         return steps;
     }
-    // Choose Perplexity tool based on intent
+    // Choose the parallel-cli command based on intent.
+    // search → facts/quick; research run → deep multi-source/reasoning.
     switch (input.intent) {
         case 'fact_check':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_ask',
-                description: 'Quick fact check with citations',
+                tool: 'Bash',
+                description: 'Quick fact check with citations via parallel-cli search',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    search_context_size: 'medium',
-                    ...(input.recencyFilter && { search_recency_filter: input.recencyFilter }),
-                    ...(input.domainFilter && { search_domain_filter: input.domainFilter }),
+                    command: `parallel-cli search ${shq(query)}${searchFlags(input)}`,
                 },
             });
             break;
         case 'compare':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_reason',
-                description: 'Step-by-step comparison with web grounding',
+                tool: 'Bash',
+                description: 'Step-by-step comparison with web grounding via parallel-cli research run',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    search_context_size: 'high',
-                    ...(input.recencyFilter && { search_recency_filter: input.recencyFilter }),
-                    ...(input.domainFilter && { search_domain_filter: input.domainFilter }),
+                    command: `parallel-cli research run --text ${shq(withResearchConstraints(query, input))} --text-description ${shq('step-by-step reasoning')} --processor pro -o .premium/research/research-compare`,
                 },
             });
             break;
         case 'explore':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_research',
-                description: 'Deep multi-source research (30s+)',
+                tool: 'Bash',
+                description: 'Deep multi-source research (30s+) via parallel-cli research run',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    reasoning_effort: 'medium',
+                    command: `parallel-cli research run --text ${shq(withResearchConstraints(query, input))} --processor pro -o .premium/research/research-explore`,
                 },
             });
             break;
         case 'how_to':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_ask',
-                description: 'Find implementation guidance',
+                tool: 'Bash',
+                description: 'Find implementation guidance via parallel-cli search',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    search_context_size: 'high',
-                    ...(input.recencyFilter && { search_recency_filter: input.recencyFilter }),
-                    ...(input.domainFilter && { search_domain_filter: input.domainFilter }),
+                    command: `parallel-cli search ${shq(query)} --mode advanced${searchFlags(input)}`,
                 },
             });
             break;
         case 'current_state':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_ask',
-                description: 'Get current state with recency filter',
+                tool: 'Bash',
+                description: 'Get current state with recency filter via parallel-cli search',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    search_recency_filter: input.recencyFilter ?? 'week',
-                    search_context_size: 'medium',
-                    ...(input.domainFilter && { search_domain_filter: input.domainFilter }),
+                    command: `parallel-cli search ${shq(query)}${searchFlags(input, 'week')}`,
                 },
             });
             break;
     }
-    // If specific URLs provided, add Firecrawl scrape steps
+    // If specific URLs provided, add parallel-cli extract steps
     if (input.scrapeUrls?.length) {
         for (const url of input.scrapeUrls) {
             steps.push({
-                tool: 'mcp__firecrawl__firecrawl_scrape',
-                description: `Scrape ${url}`,
+                tool: 'Bash',
+                description: `Extract clean markdown from ${url} via parallel-cli extract`,
                 args: {
-                    url,
-                    formats: ['markdown'],
-                    onlyMainContent: true,
+                    command: `parallel-cli extract ${shq(url)}`,
                 },
             });
         }
     }
-    // For explore/compare, also suggest a Firecrawl search for additional sources
+    // For explore/compare, also suggest a parallel-cli search for additional sources
     if (input.intent === 'explore' || input.intent === 'compare') {
         steps.push({
-            tool: 'mcp__firecrawl__firecrawl_search',
-            description: 'Search for additional sources',
+            tool: 'Bash',
+            description: 'Search for additional sources via parallel-cli search',
             args: {
-                query,
-                limit: 5,
-                sources: [{ type: 'web' }],
+                command: `parallel-cli search ${shq(query)} --max-results 5`,
             },
         });
     }
@@ -285,6 +321,7 @@ export async function researchHandler(graph, input, vault, projectSlug) {
                     researchId: node.id,
                     query: input.query,
                     intent: input.intent,
+                    prerequisite: 'parallel-cli must be installed and authenticated. Install: `npm i -g parallel-cli` (or `pipx install parallel-cli`). Auth: run `parallel-cli login` (device OAuth) or set PARALLEL_API_KEY. Verify with `parallel-cli auth`.',
                     actionPlan,
                     ingestStep: {
                         tool: 'research',

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

@@ -11,7 +11,7 @@ export declare const routeSkillsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     request: string;
     areas?: string[] | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     currentState?: "unknown" | "new" | "existing" | undefined;
     goalVerb?: string | undefined;
     detectedNeeds?: string[] | undefined;
@@ -19,7 +19,7 @@ export declare const routeSkillsSchema: z.ZodObject<{
 }, {
     request: string;
     areas?: string[] | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     currentState?: "unknown" | "new" | "existing" | undefined;
     goalVerb?: string | undefined;
     detectedNeeds?: string[] | undefined;

package/dist/tools/think.js

@@ -65,7 +65,7 @@ function buildSuggestions(type, thoughtNumber, relatedCount, stats, matchedSkill
     if (type === 'research') {
         suggestions.push({
             tool: 'research',
-            when: 'Use the research tool instead — it generates an action plan with Perplexity/Firecrawl calls and handles ingestion',
+            when: 'Use the research tool instead — it generates an action plan with `parallel-cli` (search/research run/extract) calls and handles ingestion',
             example: { query: '<what to research>', intent: 'explore' },
         });
     }

package/package.json

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