context-mcp-server 1.0.6 → 1.0.8

package/src/tools/plan.js

@@ -0,0 +1,130 @@
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import {
+  saveDiscussion, getDiscussion, listDiscussions,
+  deleteDiscussion, updateDiscussion,
+} from '../db.js';
+
+function writePlanFile(planDir, name, content, title) {
+  if (!planDir) return null;
+  const dir = resolve(planDir);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  const filePath = join(dir, `${slug}.md`);
+  const md = `# ${title || name}\n\n${content || ''}\n`;
+  writeFileSync(filePath, md, 'utf8');
+  return filePath;
+}
+
+export const definition = {
+  name: 'plan',
+  description:
+    `AI plan storage — auto-call this tool whenever you create any kind of plan.\n` +
+    `Saves a summary of the plan to the project store and writes a .md file to planDir.\n` +
+    `• "save"   — Store a new plan or overwrite an existing one by name. Pass planDir to write a file.\n` +
+    `• "update" — Patch title/content/status on an existing plan.\n` +
+    `• "get"    — Retrieve a plan by name or id (full content).\n` +
+    `• "list"   — List all plans for the project.\n` +
+    `• "delete" — Remove a plan by name or id.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action:  { type: 'string', enum: ['save', 'get', 'list', 'update', 'delete'] },
+      name:    { type: 'string', description: 'Short slug-style identifier for the plan, e.g. "auth-refactor"' },
+      id:      { type: 'string' },
+      project: { type: 'string' },
+      title:   { type: 'string', description: 'Human-readable plan title' },
+      content: { type: 'string', description: 'Full plan summary in markdown' },
+      status:  { type: 'string', enum: ['active', 'done'] },
+      tags:    { type: 'array', items: { type: 'string' } },
+      planDir: { type: 'string', description: 'Absolute path to the folder where .md plan files are written. Pass the path for your AI platform (e.g. ~/.claude/plans/ for Claude Code).' },
+    },
+    required: ['action'],
+  },
+  outputSchema: {
+    type: 'object',
+    properties: {
+      success:  { type: 'boolean' },
+      id:       { type: 'string' },
+      name:     { type: 'string' },
+      filePath: { type: 'string' },
+      plan:     { type: 'object' },
+      plans:    { type: 'array' },
+      message:  { type: 'string' },
+    },
+  },
+};
+
+export async function handle(args, state) {
+  if (!args.project && state.sessionProject) args = { ...args, project: state.sessionProject };
+
+  switch (args.action) {
+    case 'save': {
+      if (!args.name)    throw new Error('name is required for save');
+      if (!args.content) throw new Error('content is required for save');
+      const plan = saveDiscussion({
+        name:        args.name,
+        title:       args.title || args.name,
+        content:     args.content,
+        project:     args.project,
+        tags:        args.tags,
+        type:        'plan',
+        status:      args.status || 'active',
+        sessionId:   state.sessionId || null,
+      });
+      if (plan.status === 'active') state.discussionId = plan.id;
+      const filePath = writePlanFile(args.planDir, args.name, args.content, args.title);
+      return {
+        success: true, id: plan.id, name: plan.name,
+        filePath: filePath || undefined,
+        message: `Plan "${plan.name}" saved.${filePath ? ` Written to ${filePath}` : ''}`,
+      };
+    }
+
+    case 'update': {
+      if (!args.name && !args.id) throw new Error('name or id is required for update');
+      const updated = updateDiscussion({
+        name:    args.name,
+        id:      args.id,
+        title:   args.title,
+        content: args.content,
+        status:  args.status,
+        tags:    args.tags,
+      });
+      if (!updated) throw new Error(`No plan found for "${args.name || args.id}".`);
+      if (updated.status !== 'active' && state.discussionId === updated.id) state.discussionId = null;
+      if (updated.status === 'active') state.discussionId = updated.id;
+      const filePath = writePlanFile(args.planDir, updated.name, updated.content, updated.title);
+      return {
+        success: true, id: updated.id, name: updated.name, status: updated.status,
+        filePath: filePath || undefined,
+        message: `Plan "${updated.name}" updated (${updated.status}).`,
+      };
+    }
+
+    case 'get': {
+      if (!args.name && !args.id) throw new Error('name or id is required for get');
+      const plan = getDiscussion({ name: args.name, id: args.id, project: args.project });
+      return plan
+        ? { plan }
+        : { plan: null, message: `No plan found for "${args.name || args.id}".` };
+    }
+
+    case 'list': {
+      const plans = listDiscussions({ project: args.project, status: args.status });
+      return { plans };
+    }
+
+    case 'delete': {
+      if (!args.name && !args.id) throw new Error('name or id is required for delete');
+      const result = deleteDiscussion({ name: args.name, id: args.id });
+      if (state.discussionId && (args.id === state.discussionId || result.deleted > 0)) {
+        state.discussionId = null;
+      }
+      return { ...result, message: `Deleted ${result.deleted} plan(s).` };
+    }
+
+    default:
+      throw new Error(`Unknown plan action: ${args.action}`);
+  }
+}

package/uv.lock

@@ -168,7 +168,7 @@ wheels = [
 
 [[package]]
 name = "codegraph-mcp"
-version = "1.0.5"
+version = "1.0.8"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

package/codegraph/extractors/audio_extractor.py

@@ -1,8 +0,0 @@
-"""
-audio_extractor.py — audio files are not supported without faster-whisper.
-Stub kept so imports don't break.
-"""
-
-
-def transcribe(_path: str) -> str:
-    return ""

package/codegraph/extractors/doc_extractor.py

@@ -1,34 +0,0 @@
-"""
-doc_extractor.py — extract plain text from doc and PDF files.
-PDF extraction uses pymupdf if installed; falls back to label-only otherwise.
-"""
-
-from pathlib import Path
-
-
-def extract_text(path: str) -> str:
-    """Return text content of a doc/PDF file. Truncated at DOC_MAX_CHARS."""
-    from ..config import DOC_MAX_CHARS
-    if path.lower().endswith(".pdf"):
-        return _extract_pdf(path, DOC_MAX_CHARS)
-    try:
-        return Path(path).read_text(encoding="utf-8", errors="replace")[:DOC_MAX_CHARS]
-    except OSError:
-        return ""
-
-
-def _extract_pdf(path: str, max_chars: int) -> str:
-    try:
-        import pymupdf  # optional dep
-        doc = pymupdf.open(path)
-        parts = []
-        for page in doc:
-            parts.append(page.get_text())
-            if sum(len(p) for p in parts) >= max_chars:
-                break
-        doc.close()
-        return "".join(parts)[:max_chars]
-    except ImportError:
-        return f"[PDF: {Path(path).name} — install pymupdf to extract text]"
-    except Exception:
-        return ""

package/codegraph/extractors/image_extractor.py

@@ -1,26 +0,0 @@
-"""
-image_extractor.py — encode images as base64 for AI vision.
-No external deps — stdlib only.
-"""
-
-import base64
-import mimetypes
-from pathlib import Path
-
-
-def extract_image_b64(path: str) -> dict | None:
-    """Return {"data": base64_str, "media_type": "image/png"} or None on failure."""
-    try:
-        data = Path(path).read_bytes()
-        media_type = mimetypes.guess_type(path)[0] or "image/png"
-        return {"data": base64.b64encode(data).decode(), "media_type": media_type}
-    except OSError:
-        return None
-
-
-def extract_svg_text(path: str) -> str:
-    """Return SVG file as plain text (SVGs are XML — readable as-is)."""
-    try:
-        return Path(path).read_text(encoding="utf-8", errors="replace")[:4000]
-    except OSError:
-        return ""

package/src/tools/discussion.js

@@ -1,123 +0,0 @@
-import {
-  saveDiscussion, getDiscussion, listDiscussions, deleteDiscussion,
-  updateDiscussion, updateDiscussionStep, clearDiscussionLink,
-} from '../db.js';
-
-export const definition = {
-  name: 'discussion',
-  description:
-    `Forward-looking thinking space — plans, research, ideas, design.\n` +
-    `• "save"        — Create or update a discussion.\n` +
-    `• "update"      — Patch specific fields without touching the rest.\n` +
-    `• "get"         — Retrieve by name or id (full content + steps).\n` +
-    `• "list"        — List discussions (filterable). Header + stepsSummary only.\n` +
-    `• "delete"      — Remove by name or id.\n` +
-    `• "update_step" — Mark a step done/in-progress. Auto-closes when all done.`,
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action:           { type: 'string', enum: ['save', 'get', 'list', 'delete', 'update', 'update_step'] },
-      name:             { type: 'string' },
-      id:               { type: 'string' },
-      project:          { type: 'string' },
-      title:            { type: 'string' },
-      description:      { type: 'string' },
-      content:          { type: 'string' },
-      type:             { type: 'string', enum: ['plan', 'research', 'idea', 'design', 'implementation', 'review', 'thread'] },
-      status:           { type: 'string', enum: ['active', 'done'] },
-      tags:             { type: 'array', items: { type: 'string' } },
-      parentId:         { type: 'string' },
-      linkedContextIds: { type: 'array', items: { type: 'string' } },
-      steps:            { type: 'array', items: { type: 'object' } },
-      stepId:           { type: 'string' },
-      stepStatus:       { type: 'string', enum: ['pending', 'in-progress', 'done', 'skipped'] },
-      linkedContextId:  { type: 'string' },
-      filterStatus:     { type: 'string' },
-      filterType:       { type: 'string' },
-    },
-    required: ['action'],
-  },
-  outputSchema: {
-    type: 'object',
-    properties: {
-      success:     { type: 'boolean' },
-      id:          { type: 'string' },
-      name:        { type: 'string' },
-      discussion:  { type: 'object' },
-      discussions: { type: 'array' },
-      step:        { type: 'object' },
-      message:     { type: 'string' },
-    },
-  },
-};
-
-export async function handle(args, state) {
-  switch (args.action) {
-    case 'save': {
-      if (!args.name) throw new Error('name is required for save');
-      const disc = saveDiscussion({ ...args, sessionId: args.sessionId || state.sessionId });
-      if (disc.status === 'active')                                  state.discussionId = disc.id;
-      else if (state.discussionId === disc.id)                       state.discussionId = null;
-      return { success: true, id: disc.id, name: disc.name,
-        message: `Discussion "${disc.name}" saved (${disc.type}, ${disc.status}).` };
-    }
-
-    case 'get': {
-      if (!args.name && !args.id) throw new Error('name or id is required for get');
-      const disc = getDiscussion({ name: args.name, id: args.id, project: args.project });
-      return disc
-        ? { discussion: disc }
-        : { discussion: null, message: `No discussion found for "${args.name || args.id}".` };
-    }
-
-    case 'update': {
-      if (!args.name && !args.id) throw new Error('name or id is required for update');
-      const updated = updateDiscussion({ ...args });
-      if (!updated) throw new Error(`No discussion found for "${args.name || args.id}".`);
-      if (updated.status !== 'active' && state.discussionId === updated.id) state.discussionId = null;
-      if (updated.status === 'active')                                        state.discussionId = updated.id;
-      return { success: true, id: updated.id, name: updated.name, status: updated.status,
-        message: `Discussion "${updated.name}" updated (${updated.status}).` };
-    }
-
-    case 'list': {
-      return { discussions: listDiscussions({ project: args.project, status: args.filterStatus, type: args.filterType }) };
-    }
-
-    case 'delete': {
-      if (!args.name && !args.id) throw new Error('name or id is required for delete');
-      const toDelete = getDiscussion({ name: args.name, id: args.id });
-      if (toDelete) {
-        for (const ctxId of (toDelete.linkedContextIds || [])) clearDiscussionLink(ctxId);
-      }
-      const del = deleteDiscussion({ name: args.name, id: args.id });
-      if (state.discussionId) {
-        const matchById   = args.id   && args.id   === state.discussionId;
-        const matchByName = args.name && del.deleted > 0;
-        if (matchById || matchByName) state.discussionId = null;
-      }
-      return { ...del, message: `Deleted ${del.deleted} discussion(s).` };
-    }
-
-    case 'update_step': {
-      if (!args.name && !args.id) throw new Error('name or id is required for update_step');
-      if (!args.stepId) throw new Error('stepId is required for update_step');
-      const updated = updateDiscussionStep({
-        discussionName:  args.name,
-        discussionId:    args.id,
-        stepId:          args.stepId,
-        status:          args.stepStatus,
-        linkedContextId: args.linkedContextId,
-      });
-      if (!updated) throw new Error('Discussion or step not found.');
-      if (updated.discussion.status === 'done' && state.discussionId === updated.discussion.id) {
-        state.discussionId = null;
-      }
-      return { success: true, step: updated.step, discussionStatus: updated.discussion.status,
-        message: `Step updated. Discussion "${updated.discussion.name}" is now "${updated.discussion.status}".` };
-    }
-
-    default:
-      throw new Error(`Unknown discussion action: ${args.action}`);
-  }
-}