kernelbot 1.0.37 → 1.0.38

package/src/tools/linkedin.js

@@ -0,0 +1,264 @@
+import { LinkedInAPI } from '../services/linkedin-api.js';
+import { getLogger } from '../utils/logger.js';
+
+/**
+ * Get a configured LinkedIn API client from the tool context.
+ * Expects context.config.linkedin.access_token and context.config.linkedin.person_urn
+ * to be injected at dispatch time.
+ */
+function getClient(context) {
+  const token = context.config.linkedin?.access_token;
+  if (!token) throw new Error('LinkedIn not connected. Use /linkedin link to connect your account.');
+  return new LinkedInAPI(token);
+}
+
+function getPersonUrn(context) {
+  const urn = context.config.linkedin?.person_urn;
+  if (!urn) throw new Error('LinkedIn person URN not available. Try /linkedin link again.');
+  return urn;
+}
+
+export const definitions = [
+  {
+    name: 'linkedin_create_post',
+    description: 'Create a LinkedIn post. Can be text-only or include an article link.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string',
+          description: 'The post content/commentary text',
+        },
+        visibility: {
+          type: 'string',
+          enum: ['PUBLIC', 'CONNECTIONS'],
+          description: 'Post visibility (default: PUBLIC)',
+        },
+        article_url: {
+          type: 'string',
+          description: 'Optional URL to share as an article attachment',
+        },
+        article_title: {
+          type: 'string',
+          description: 'Optional title for the shared article',
+        },
+      },
+      required: ['text'],
+    },
+  },
+  {
+    name: 'linkedin_get_my_posts',
+    description: 'Get the user\'s recent LinkedIn posts. NOTE: Requires r_member_social permission (restricted). May return 403 if the LinkedIn app is not approved for this scope.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        count: {
+          type: 'number',
+          description: 'Number of posts to fetch (default 10)',
+        },
+      },
+    },
+  },
+  {
+    name: 'linkedin_get_post',
+    description: 'Get a specific LinkedIn post by its URN. NOTE: Requires r_member_social permission (restricted). May return 403 if the LinkedIn app is not approved for this scope.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        post_urn: {
+          type: 'string',
+          description: 'The LinkedIn post URN (e.g. urn:li:share:12345)',
+        },
+      },
+      required: ['post_urn'],
+    },
+  },
+  {
+    name: 'linkedin_comment_on_post',
+    description: 'Add a comment to a LinkedIn post.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        post_urn: {
+          type: 'string',
+          description: 'The LinkedIn post URN to comment on',
+        },
+        comment: {
+          type: 'string',
+          description: 'The comment text',
+        },
+      },
+      required: ['post_urn', 'comment'],
+    },
+  },
+  {
+    name: 'linkedin_get_comments',
+    description: 'Get comments on a LinkedIn post. NOTE: Requires r_member_social permission (restricted). May return 403 if the LinkedIn app is not approved for this scope.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        post_urn: {
+          type: 'string',
+          description: 'The LinkedIn post URN',
+        },
+        count: {
+          type: 'number',
+          description: 'Number of comments to fetch (default 10)',
+        },
+      },
+      required: ['post_urn'],
+    },
+  },
+  {
+    name: 'linkedin_like_post',
+    description: 'Like a LinkedIn post.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        post_urn: {
+          type: 'string',
+          description: 'The LinkedIn post URN to like',
+        },
+      },
+      required: ['post_urn'],
+    },
+  },
+  {
+    name: 'linkedin_get_profile',
+    description: 'Get the linked LinkedIn profile information. NOTE: Requires "Sign in with LinkedIn" product (openid + profile scopes). Returns limited info if only w_member_social is available.',
+    input_schema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'linkedin_delete_post',
+    description: 'Delete a LinkedIn post.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        post_urn: {
+          type: 'string',
+          description: 'The LinkedIn post URN to delete',
+        },
+      },
+      required: ['post_urn'],
+    },
+  },
+];
+
+export const handlers = {
+  linkedin_create_post: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const authorUrn = getPersonUrn(context);
+      const visibility = params.visibility || 'PUBLIC';
+
+      let result;
+      if (params.article_url) {
+        result = await client.createArticlePost(authorUrn, params.text, params.article_url, params.article_title);
+      } else {
+        result = await client.createTextPost(authorUrn, params.text, visibility);
+      }
+
+      return { success: true, message: 'Post created successfully', post: result };
+    } catch (err) {
+      getLogger().error(`linkedin_create_post failed: ${err.message}`);
+      return { error: err.response?.data?.message || err.message };
+    }
+  },
+
+  linkedin_get_my_posts: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const authorUrn = getPersonUrn(context);
+      const posts = await client.getMyPosts(authorUrn, params.count || 10);
+      return { posts, count: posts.length };
+    } catch (err) {
+      getLogger().error(`linkedin_get_my_posts failed: ${err.message}`);
+      if (err.response?.status === 403) {
+        return { error: 'Access denied — reading posts requires r_member_social permission which is restricted to approved LinkedIn apps. Your token only has w_member_social (write-only: post, comment, like).' };
+      }
+      return { error: err.response?.data?.message || err.message };
+    }
+  },
+
+  linkedin_get_post: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const post = await client.getPost(params.post_urn);
+      return { post };
+    } catch (err) {
+      getLogger().error(`linkedin_get_post failed: ${err.message}`);
+      if (err.response?.status === 403) {
+        return { error: 'Access denied — reading posts requires r_member_social permission which is restricted to approved LinkedIn apps.' };
+      }
+      return { error: err.response?.data?.message || err.message };
+    }
+  },
+
+  linkedin_comment_on_post: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const actorUrn = getPersonUrn(context);
+      const result = await client.addComment(params.post_urn, params.comment, actorUrn);
+      return { success: true, message: 'Comment posted', comment: result };
+    } catch (err) {
+      getLogger().error(`linkedin_comment_on_post failed: ${err.message}`);
+      return { error: err.response?.data?.message || err.message };
+    }
+  },
+
+  linkedin_get_comments: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const comments = await client.getComments(params.post_urn, params.count || 10);
+      return { comments, count: comments.length };
+    } catch (err) {
+      getLogger().error(`linkedin_get_comments failed: ${err.message}`);
+      if (err.response?.status === 403) {
+        return { error: 'Access denied — reading comments requires r_member_social permission which is restricted to approved LinkedIn apps.' };
+      }
+      return { error: err.response?.data?.message || err.message };
+    }
+  },
+
+  linkedin_like_post: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const actorUrn = getPersonUrn(context);
+      const result = await client.likePost(params.post_urn, actorUrn);
+      return { success: true, message: 'Post liked', result };
+    } catch (err) {
+      getLogger().error(`linkedin_like_post failed: ${err.message}`);
+      return { error: err.response?.data?.message || err.message };
+    }
+  },
+
+  linkedin_get_profile: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const profile = await client.getProfile();
+      if (!profile) {
+        // No openid+profile scopes — return what we know from config
+        const urn = context.config.linkedin?.person_urn;
+        return { profile: { person_urn: urn }, note: 'Full profile unavailable — LinkedIn app only has w_member_social scope. Add "Sign in with LinkedIn" product for full profile access.' };
+      }
+      return { profile };
+    } catch (err) {
+      getLogger().error(`linkedin_get_profile failed: ${err.message}`);
+      return { error: err.response?.data?.message || err.message };
+    }
+  },
+
+  linkedin_delete_post: async (params, context) => {
+    try {
+      const client = getClient(context);
+      await client.deletePost(params.post_urn);
+      return { success: true, message: 'Post deleted' };
+    } catch (err) {
+      getLogger().error(`linkedin_delete_post failed: ${err.message}`);
+      return { error: err.response?.data?.message || err.message };
+    }
+  },
+};

package/src/tools/orchestrator-tools.js

@@ -5,7 +5,35 @@ import { getLogger } from '../utils/logger.js';
 const workerTypeEnum = Object.keys(WORKER_TYPES);
 
 /**
- * Tool definitions for the orchestrator's 3 meta-tools.
+ * Tokenize a task string for similarity comparison.
+ * Lowercase, strip punctuation, filter words ≤2 chars.
+ */
+function tokenize(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 2);
+}
+
+/**
+ * Jaccard word-overlap similarity between two task strings.
+ * Returns a value between 0 and 1.
+ */
+function taskSimilarity(a, b) {
+  const setA = new Set(tokenize(a));
+  const setB = new Set(tokenize(b));
+  if (setA.size === 0 && setB.size === 0) return 1;
+  if (setA.size === 0 || setB.size === 0) return 0;
+  let intersection = 0;
+  for (const word of setA) {
+    if (setB.has(word)) intersection++;
+  }
+  return intersection / (setA.size + setB.size - intersection);
+}
+
+/**
+ * Tool definitions for the orchestrator's meta-tools.
  */
 export const orchestratorToolDefinitions = [
   {
@@ -58,6 +86,20 @@ export const orchestratorToolDefinitions = [
       required: ['job_id'],
     },
   },
+  {
+    name: 'check_job',
+    description: 'Get detailed diagnostics for a specific job — status, elapsed time, activity log, and stuck detection. Use this to investigate workers that seem slow or unresponsive.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        job_id: {
+          type: 'string',
+          description: 'The ID of the job to check.',
+        },
+      },
+      required: ['job_id'],
+    },
+  },
   {
     name: 'create_automation',
     description: 'Create a recurring automation that runs on a schedule. The task description will be executed as a standalone prompt each time it fires.',
@@ -176,6 +218,60 @@ export const orchestratorToolDefinitions = [
       required: ['emoji'],
     },
   },
+  {
+    name: 'recall_memories',
+    description: 'Search your episodic and semantic memory for information about a topic, event, or past experience. Use this when the user references something from the past or you need context about a specific subject.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Keywords or topic to search memories for (e.g. "kubernetes", "birthday", "project deadline").',
+        },
+        time_range_hours: {
+          type: 'number',
+          description: 'Optional: limit episodic search to the last N hours. Defaults to searching all available memories.',
+        },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'recall_user_history',
+    description: 'Retrieve memories specifically about a user — past interactions, preferences, things they told you. Use when you need to remember what a specific person has shared or discussed.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        user_id: {
+          type: 'string',
+          description: 'The user ID to retrieve memories for.',
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of memories to return. Default: 10.',
+        },
+      },
+      required: ['user_id'],
+    },
+  },
+  {
+    name: 'search_conversations',
+    description: 'Search past messages in the current (or specified) chat for a keyword or phrase. Use when you need to find something specific that was said in conversation.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Keyword or phrase to search for in conversation history.',
+        },
+        chat_id: {
+          type: 'string',
+          description: 'Optional: chat ID to search. Defaults to the current chat.',
+        },
+      },
+      required: ['query'],
+    },
+  },
 ];
 
 /**
@@ -259,6 +355,26 @@ export async function executeOrchestratorTool(name, input, context) {
         }
       }
 
+      // Duplicate task detection — compare against running + queued jobs in this chat
+      const activeJobs = jobManager.getJobsForChat(chatId)
+        .filter(j => (j.status === 'running' || j.status === 'queued') && j.workerType === worker_type);
+
+      for (const existing of activeJobs) {
+        const sim = taskSimilarity(task, existing.task);
+        if (sim > 0.7) {
+          logger.warn(`[dispatch_task] Duplicate blocked — ${(sim * 100).toFixed(0)}% similar to job ${existing.id}: "${existing.task.slice(0, 80)}"`);
+          return {
+            error: `A very similar ${worker_type} task is already ${existing.status} (job ${existing.id}, ${(sim * 100).toFixed(0)}% match). Wait for it to finish or cancel it first.`,
+            existing_job_id: existing.id,
+            similarity: Math.round(sim * 100),
+          };
+        }
+        if (sim > 0.4) {
+          logger.info(`[dispatch_task] Similar task warning — ${(sim * 100).toFixed(0)}% overlap with job ${existing.id}`);
+          credentialWarning = [credentialWarning, `Warning: This task is ${(sim * 100).toFixed(0)}% similar to an active ${worker_type} job (${existing.id}). Proceeding anyway.`].filter(Boolean).join('\n');
+        }
+      }
+
       // Create the job with context and dependencies
       const job = jobManager.createJob(chatId, worker_type, task);
       job.context = [taskContext, credentialWarning].filter(Boolean).join('\n\n') || null;
@@ -288,12 +404,21 @@ export async function executeOrchestratorTool(name, input, context) {
         }
       });
 
-      return {
+      // Collect sibling active jobs for awareness
+      const siblingJobs = jobManager.getJobsForChat(chatId)
+        .filter(j => j.id !== job.id && (j.status === 'running' || j.status === 'queued'))
+        .map(j => ({ id: j.id, worker_type: j.workerType, status: j.status, task: j.task.slice(0, 80) }));
+
+      const result = {
         job_id: job.id,
         worker_type,
         status: 'dispatched',
         message: `${workerConfig.emoji} ${workerConfig.label} started.`,
       };
+      if (siblingJobs.length > 0) {
+        result.other_active_jobs = siblingJobs;
+      }
+      return result;
     }
 
     case 'list_jobs': {
@@ -345,6 +470,68 @@ export async function executeOrchestratorTool(name, input, context) {
       };
     }
 
+    case 'check_job': {
+      const { job_id } = input;
+      logger.info(`[check_job] Checking job ${job_id}`);
+      const job = jobManager.getJob(job_id);
+      if (!job) {
+        return { error: `Job ${job_id} not found.` };
+      }
+
+      const now = Date.now();
+      const elapsed = job.startedAt ? Math.round((now - job.startedAt) / 1000) : 0;
+      const timeoutSec = job.timeoutMs ? Math.round(job.timeoutMs / 1000) : null;
+      const timeRemaining = (timeoutSec && job.startedAt) ? Math.max(0, timeoutSec - elapsed) : null;
+
+      const result = {
+        job_id: job.id,
+        worker_type: job.workerType,
+        status: job.status,
+        task: job.task.slice(0, 200),
+        elapsed_seconds: elapsed,
+        timeout_seconds: timeoutSec,
+        time_remaining_seconds: timeRemaining,
+        llm_calls: job.llmCalls,
+        tool_calls: job.toolCalls,
+        last_thinking: job.lastThinking ? job.lastThinking.slice(0, 300) : null,
+        recent_activity: job.progress.slice(-10),
+        last_activity_seconds_ago: job.lastActivity ? Math.round((now - job.lastActivity) / 1000) : null,
+      };
+
+      // Stuck detection diagnostics (only for running jobs)
+      // Long-running workers (coding, devops) get higher thresholds
+      if (job.status === 'running') {
+        const diagnostics = [];
+        const isLongRunning = ['coding', 'devops'].includes(job.workerType);
+        const idleThreshold = isLongRunning ? 600 : 120;
+        const loopLlmThreshold = isLongRunning ? 50 : 15;
+
+        const idleSec = job.lastActivity ? Math.round((now - job.lastActivity) / 1000) : elapsed;
+        if (idleSec > idleThreshold) {
+          diagnostics.push(`IDLE for ${idleSec}s — no activity detected`);
+        }
+        if (job.llmCalls > loopLlmThreshold && job.toolCalls < 3) {
+          diagnostics.push(`POSSIBLY LOOPING — ${job.llmCalls} LLM calls but only ${job.toolCalls} tool calls`);
+        }
+        if (timeoutSec && elapsed > timeoutSec * 0.75) {
+          const pct = Math.round((elapsed / timeoutSec) * 100);
+          diagnostics.push(`${pct}% of timeout used (${elapsed}s / ${timeoutSec}s)`);
+        }
+        if (diagnostics.length > 0) {
+          result.warnings = diagnostics;
+        }
+      }
+
+      if (job.dependsOn.length > 0) result.depends_on = job.dependsOn;
+      if (job.error) result.error = job.error;
+      if (job.structuredResult) {
+        result.result_summary = job.structuredResult.summary;
+        result.result_status = job.structuredResult.status;
+      }
+
+      return result;
+    }
+
     case 'create_automation': {
       if (!automationManager) return { error: 'Automation system not available.' };
 
@@ -479,6 +666,154 @@ export async function executeOrchestratorTool(name, input, context) {
       }
     }
 
+    case 'recall_memories': {
+      const { memoryManager } = context;
+      if (!memoryManager) return { error: 'Memory system not available.' };
+
+      const { query, time_range_hours } = input;
+      logger.info(`[recall_memories] Searching for: "${query}" (time_range=${time_range_hours || 'all'})`);
+
+      const episodic = memoryManager.searchEpisodic(query, 10);
+      const semantic = memoryManager.searchSemantic(query, 5);
+
+      // Filter by time range if specified
+      const now = Date.now();
+      const filteredEpisodic = time_range_hours
+        ? episodic.filter(m => (now - m.timestamp) <= time_range_hours * 3600_000)
+        : episodic;
+
+      const formatAge = (ts) => {
+        const ageH = Math.round((now - ts) / 3600_000);
+        if (ageH < 1) return 'just now';
+        if (ageH < 24) return `${ageH}h ago`;
+        const ageD = Math.round(ageH / 24);
+        return `${ageD}d ago`;
+      };
+
+      const episodicResults = filteredEpisodic.map(m => ({
+        summary: m.summary,
+        age: formatAge(m.timestamp),
+        importance: m.importance,
+        tags: m.tags,
+        type: m.type,
+      }));
+
+      const semanticResults = semantic.map(s => ({
+        topic: s.topic,
+        summary: s.summary,
+        learned: formatAge(s.learnedAt),
+        related: s.relatedTopics,
+      }));
+
+      logger.info(`[recall_memories] Found ${episodicResults.length} episodic, ${semanticResults.length} semantic results for query="${query}"`);
+
+      // Detailed logging — show what was actually recalled
+      for (const m of episodicResults) {
+        logger.info(`[recall_memories]   📝 [${m.age}, imp=${m.importance}] ${m.summary.slice(0, 120)}`);
+      }
+      for (const s of semanticResults) {
+        logger.info(`[recall_memories]   🧠 [${s.topic}] ${s.summary.slice(0, 120)}`);
+      }
+
+      if (episodicResults.length === 0 && semanticResults.length === 0) {
+        logger.info(`[recall_memories] No results found for query="${query}"`);
+        return { message: `No memories found matching "${query}".` };
+      }
+
+      return {
+        query,
+        episodic: episodicResults,
+        semantic: semanticResults,
+      };
+    }
+
+    case 'recall_user_history': {
+      const { memoryManager } = context;
+      if (!memoryManager) return { error: 'Memory system not available.' };
+
+      const { user_id, limit } = input;
+      logger.info(`[recall_user_history] Retrieving memories for user: ${user_id} (limit=${limit || 10})`);
+
+      const memories = memoryManager.getMemoriesAboutUser(user_id, limit || 10);
+
+      const now = Date.now();
+      const results = memories.map(m => ({
+        summary: m.summary,
+        age: (() => {
+          const ageH = Math.round((now - m.timestamp) / 3600_000);
+          if (ageH < 1) return 'just now';
+          if (ageH < 24) return `${ageH}h ago`;
+          return `${Math.round(ageH / 24)}d ago`;
+        })(),
+        importance: m.importance,
+        type: m.type,
+        tags: m.tags,
+      }));
+
+      logger.info(`[recall_user_history] Found ${results.length} memories for user ${user_id}`);
+
+      // Detailed logging — show each recalled memory
+      for (const m of results) {
+        logger.info(`[recall_user_history]   📝 [${m.age}, imp=${m.importance}, ${m.type}] ${m.summary.slice(0, 120)}`);
+      }
+
+      if (results.length === 0) {
+        logger.info(`[recall_user_history] No memories found for user ${user_id}`);
+        return { message: `No memories found for user ${user_id}.` };
+      }
+
+      return { user_id, memories: results };
+    }
+
+    case 'search_conversations': {
+      const { conversationManager } = context;
+      if (!conversationManager) return { error: 'Conversation system not available.' };
+
+      const { query, chat_id } = input;
+      const targetChatId = chat_id || chatId;
+      logger.info(`[search_conversations] Searching chat ${targetChatId} for: "${query}"`);
+
+      const history = conversationManager.getHistory(targetChatId);
+      const queryLower = query.toLowerCase();
+
+      const matches = [];
+      for (let i = 0; i < history.length; i++) {
+        const msg = history[i];
+        const content = typeof msg.content === 'string' ? msg.content : '';
+        if (content.toLowerCase().includes(queryLower)) {
+          matches.push({
+            role: msg.role,
+            snippet: content.length > 300 ? content.slice(0, 300) + '...' : content,
+            age: msg.timestamp
+              ? (() => {
+                  const ageH = Math.round((Date.now() - msg.timestamp) / 3600_000);
+                  if (ageH < 1) return 'just now';
+                  if (ageH < 24) return `${ageH}h ago`;
+                  return `${Math.round(ageH / 24)}d ago`;
+                })()
+              : 'unknown',
+          });
+        }
+      }
+
+      // Return last 10 matches (most recent)
+      const results = matches.slice(-10);
+
+      logger.info(`[search_conversations] Found ${matches.length} total matches in chat ${targetChatId}, returning last ${results.length}`);
+
+      // Detailed logging — show matched conversation snippets
+      for (const m of results) {
+        logger.info(`[search_conversations]   💬 [${m.role}, ${m.age}] ${m.snippet.slice(0, 100)}`);
+      }
+
+      if (results.length === 0) {
+        logger.info(`[search_conversations] No matches for "${query}" in chat ${targetChatId}`);
+        return { message: `No messages found matching "${query}" in this chat.` };
+      }
+
+      return { query, chat_id: targetChatId, matches: results, total_matches: matches.length };
+    }
+
     default:
       return { error: `Unknown orchestrator tool: ${name}` };
   }