@squidcode/forever-plugin 0.1.0 → 0.3.0

package/dist/index.js

@@ -2,15 +2,51 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import { execFileSync } from 'child_process';
+import { randomBytes } from 'crypto';
+import { basename } from 'path';
 import { createApiClient } from './client.js';
 import { getOrCreateMachineId } from './machine.js';
 const server = new McpServer({
     name: 'forever',
-    version: '0.1.0',
+    version: '0.3.0',
 });
 const machineId = getOrCreateMachineId();
+const sessionId = `${Date.now()}-${randomBytes(4).toString('hex')}`;
+function git(...args) {
+    try {
+        return execFileSync('git', args, {
+            encoding: 'utf-8',
+            timeout: 5000,
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function getGitContext() {
+    return {
+        gitBranch: git('rev-parse', '--abbrev-ref', 'HEAD'),
+        gitCommit: git('rev-parse', '--short', 'HEAD'),
+        directory: process.cwd(),
+    };
+}
+function resolveProject(explicit) {
+    if (explicit)
+        return explicit;
+    const remote = git('remote', 'get-url', 'origin');
+    if (remote)
+        return remote;
+    const dir = process.cwd();
+    if (dir && dir !== '/')
+        return basename(dir);
+    return null;
+}
 server.tool('memory_log', 'Log an entry to Forever memory (summary, decision, or error)', {
-    project: z.string().describe('Project name or git remote URL'),
+    project: z
+        .string()
+        .optional()
+        .describe('Project name or git remote URL (auto-detected from git if omitted)'),
     type: z
         .enum(['summary', 'decision', 'error'])
         .describe('Type of memory entry'),
@@ -19,30 +55,51 @@ server.tool('memory_log', 'Log an entry to Forever memory (summary, decision, or
         .array(z.string())
         .optional()
         .describe('Optional tags for categorization'),
-    sessionId: z.string().optional().describe('Session ID for grouping'),
-}, async ({ project, type, content, tags, sessionId }) => {
+    sessionId: z
+        .string()
+        .optional()
+        .describe('Session ID for grouping (auto-generated if omitted)'),
+}, async ({ project, type, content, tags, sessionId: explicitSessionId }) => {
     const api = createApiClient();
     if (!api) {
         return {
             content: [
                 {
                     type: 'text',
-                    text: 'Not authenticated. Run: forever-plugin login',
+                    text: 'Not authenticated. Run: npx @squidcode/forever-plugin login',
                 },
             ],
         };
     }
+    const resolvedProject = resolveProject(project);
+    if (!resolvedProject) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Could not detect project. Please specify a project name.',
+                },
+            ],
+        };
+    }
+    const gitContext = getGitContext();
     try {
         await api.post('/logs', {
-            project,
+            project: resolvedProject,
             type,
             content,
             machineId,
             tags,
-            sessionId,
+            sessionId: explicitSessionId || sessionId,
+            ...gitContext,
         });
         return {
-            content: [{ type: 'text', text: `Logged ${type} entry.` }],
+            content: [
+                {
+                    type: 'text',
+                    text: `Logged ${type} entry for "${resolvedProject}".`,
+                },
+            ],
         };
     }
     catch (err) {
@@ -57,7 +114,10 @@ server.tool('memory_log', 'Log an entry to Forever memory (summary, decision, or
     }
 });
 server.tool('memory_get_recent', 'Get recent memory entries for a project', {
-    project: z.string().describe('Project name or git remote URL'),
+    project: z
+        .string()
+        .optional()
+        .describe('Project name or git remote URL (auto-detected from git if omitted)'),
     limit: z
         .number()
         .optional()
@@ -70,14 +130,25 @@ server.tool('memory_get_recent', 'Get recent memory entries for a project', {
             content: [
                 {
                     type: 'text',
-                    text: 'Not authenticated. Run: forever-plugin login',
+                    text: 'Not authenticated. Run: npx @squidcode/forever-plugin login',
+                },
+            ],
+        };
+    }
+    const resolvedProject = resolveProject(project);
+    if (!resolvedProject) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Could not detect project. Please specify a project name.',
                 },
             ],
         };
     }
     try {
         const res = await api.get('/logs/recent', {
-            params: { project, limit },
+            params: { project: resolvedProject, limit },
         });
         const logs = res.data;
         if (!logs.length) {
@@ -85,7 +156,7 @@ server.tool('memory_get_recent', 'Get recent memory entries for a project', {
                 content: [
                     {
                         type: 'text',
-                        text: `No memory entries found for project "${project}".`,
+                        text: `No memory entries found for project "${resolvedProject}".`,
                     },
                 ],
             };
@@ -106,6 +177,85 @@ server.tool('memory_get_recent', 'Get recent memory entries for a project', {
         };
     }
 });
+server.tool('memory_get_sessions', 'Get recent sessions for a project, grouped by session with machine info. Use at startup to detect cross-machine handoffs.', {
+    project: z
+        .string()
+        .optional()
+        .describe('Project name or git remote URL (auto-detected from git if omitted)'),
+    limit: z
+        .number()
+        .optional()
+        .default(10)
+        .describe('Number of recent sessions to fetch'),
+}, async ({ project, limit }) => {
+    const api = createApiClient();
+    if (!api) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Not authenticated. Run: npx @squidcode/forever-plugin login',
+                },
+            ],
+        };
+    }
+    const resolvedProject = resolveProject(project);
+    if (!resolvedProject) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Could not detect project. Please specify a project name.',
+                },
+            ],
+        };
+    }
+    try {
+        const res = await api.get('/logs/sessions', {
+            params: { project: resolvedProject, machineId, limit },
+        });
+        const { sessions, hasRemoteActivity } = res.data;
+        if (!sessions.length) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `No previous sessions found for "${resolvedProject}".`,
+                    },
+                ],
+            };
+        }
+        const lines = [];
+        if (hasRemoteActivity) {
+            lines.push('⚡ REMOTE ACTIVITY DETECTED — Sessions from other machines found for this project.\n');
+        }
+        for (const s of sessions) {
+            const machine = s.machineName || 'unknown';
+            const remote = s.isRemote ? ' [REMOTE]' : ' [LOCAL]';
+            const branch = s.gitBranch ? ` on ${s.gitBranch}` : '';
+            const commit = s.gitCommit ? ` @ ${s.gitCommit}` : '';
+            lines.push(`## Session ${s.sessionId}${remote}`);
+            lines.push(`Machine: ${machine}${branch}${commit}`);
+            lines.push(`Time: ${s.startedAt} → ${s.endedAt} (${s.logCount} logs)`);
+            if (s.directory)
+                lines.push(`Directory: ${s.directory}`);
+            if (s.summary)
+                lines.push(`Summary: ${s.summary}`);
+            lines.push('');
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to fetch sessions: ${err.message}`,
+                },
+            ],
+        };
+    }
+});
 server.tool('memory_search', 'Search memory entries across projects', {
     query: z.string().describe('Search query'),
     project: z.string().optional().describe('Filter by project'),
@@ -121,7 +271,7 @@ server.tool('memory_search', 'Search memory entries across projects', {
             content: [
                 {
                     type: 'text',
-                    text: 'Not authenticated. Run: forever-plugin login',
+                    text: 'Not authenticated. Run: npx @squidcode/forever-plugin login',
                 },
             ],
         };
@@ -169,7 +319,9 @@ if (process.argv[2] === 'login') {
     });
     const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
     console.log('Forever Plugin Login\n');
-    const serverUrl = await ask('Server URL (e.g. https://forever-z44hy.ondigitalocean.app): ');
+    const DEFAULT_SERVER = 'https://forever.squidcode.com';
+    const serverUrlInput = await ask(`Server URL [${DEFAULT_SERVER}]: `);
+    const serverUrl = serverUrlInput.trim() || DEFAULT_SERVER;
     const email = await ask('Email: ');
     const password = await ask('Password: ');
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcode/forever-plugin",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "MCP plugin for Forever - Claude Memory System",
   "type": "module",
   "bin": {