@mycontxt/mcp 0.1.1

package/src/tools/suggest-context.ts

@@ -0,0 +1,76 @@
+/**
+ * Suggest Context Tool - Smart context retrieval
+ * This is the killer feature of MemoCore
+ */
+
+import { SQLiteDatabase } from '@mycontxt/adapters/sqlite';
+import { rankEntries, fitToBudget, buildContext } from '@mycontxt/core';
+import type { SuggestOptions } from '@mycontxt/core';
+import { getDbPath } from '../utils/project.js';
+
+interface SuggestContextArgs {
+  taskDescription?: string;
+  activeFiles?: string[];
+  maxTokens?: number;
+  minRelevance?: number;
+  projectPath?: string;
+}
+
+export async function suggestContext(args: SuggestContextArgs): Promise<string> {
+  const projectPath = args.projectPath || process.cwd();
+  const dbPath = getDbPath(projectPath);
+
+  const db = new SQLiteDatabase(dbPath);
+  await db.initialize();
+
+  try {
+    // Get project
+    const project = await db.getProjectByPath(projectPath);
+    if (!project) {
+      return 'No MemoCore project found. Run `memocore init` to initialize.';
+    }
+
+    // Get active branch
+    const activeBranch = await db.getActiveBranch(project.id);
+
+    // Get all non-archived entries
+    const entries = await db.listEntries({
+      projectId: project.id,
+      branch: activeBranch,
+      isArchived: false,
+    });
+
+    if (entries.length === 0) {
+      return 'No memory entries found. Add some decisions, patterns, or context to get started.';
+    }
+
+    // Build suggest options
+    const options: SuggestOptions = {
+      projectId: project.id,
+      taskDescription: args.taskDescription,
+      activeFiles: args.activeFiles,
+      maxTokens: args.maxTokens || 4000,
+      minRelevance: args.minRelevance || 0.3,
+    };
+
+    // Rank entries by relevance
+    const ranked = rankEntries(entries, options);
+
+    if (ranked.length === 0) {
+      return 'No relevant entries found for the given task.';
+    }
+
+    // Fit within token budget
+    const fitted = fitToBudget(ranked, options.maxTokens);
+
+    // Build formatted context
+    const context = buildContext(fitted, {
+      includeReasons: true,
+      includeStats: true,
+    });
+
+    return context;
+  } finally {
+    await db.close();
+  }
+}

package/src/utils/project.ts

@@ -0,0 +1,19 @@
+/**
+ * Project utilities for MCP server
+ */
+
+import { join } from 'path';
+
+/**
+ * Get the .contxt directory path
+ */
+export function getContxtDir(cwd: string): string {
+  return join(cwd, '.contxt');
+}
+
+/**
+ * Get the database file path
+ */
+export function getDbPath(cwd: string): string {
+  return join(getContxtDir(cwd), 'local.db');
+}

package/src/utils/usage-gate.ts

@@ -0,0 +1,149 @@
+/**
+ * Usage gate utilities for MCP server
+ * MCP MUST NEVER throw errors - always degrade gracefully
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { UsageGate, type UsageCounts } from '@mycontxt/core/engine/usage';
+import { resolveUserPlan } from '@mycontxt/core/engine/plan-resolver';
+import { SupabaseDatabase } from '@mycontxt/adapters/supabase';
+
+const AUTH_FILE = join(homedir(), '.contxt', 'auth.json');
+
+interface AuthData {
+  accessToken: string;
+  userId: string;
+  email: string;
+}
+
+/**
+ * Get current authenticated user ID
+ */
+function getCurrentUserId(): string | null {
+  if (!existsSync(AUTH_FILE)) return null;
+
+  try {
+    const content = readFileSync(AUTH_FILE, 'utf-8');
+    const auth: AuthData = JSON.parse(content);
+    return auth.userId;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get authenticated Supabase database instance
+ */
+function getRemoteDb(): SupabaseDatabase | null {
+  if (!existsSync(AUTH_FILE)) return null;
+
+  try {
+    const content = readFileSync(AUTH_FILE, 'utf-8');
+    const auth: AuthData = JSON.parse(content);
+
+    return new SupabaseDatabase({
+      url: process.env.SUPABASE_URL || '',
+      anonKey: process.env.SUPABASE_ANON_KEY || '',
+      accessToken: auth.accessToken,
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get usage counts for gate enforcement
+ */
+async function getUsageCounts(
+  localDb: any,
+  userId: string | null,
+  projectId?: string
+): Promise<UsageCounts> {
+  const projectCountQuery = 'SELECT COUNT(*) as count FROM projects';
+  const projectRow = localDb.db.prepare(projectCountQuery).get() as any;
+  const totalProjects = projectRow.count;
+
+  const totalEntriesQuery = 'SELECT COUNT(*) as count FROM memory_entries WHERE is_archived = 0';
+  const totalEntriesRow = localDb.db.prepare(totalEntriesQuery).get() as any;
+  const totalEntries = totalEntriesRow.count;
+
+  let entriesInProject = 0;
+  if (projectId) {
+    const projectEntriesQuery = 'SELECT COUNT(*) as count FROM memory_entries WHERE project_id = ? AND is_archived = 0';
+    const projectEntriesRow = localDb.db.prepare(projectEntriesQuery).get(projectId) as any;
+    entriesInProject = projectEntriesRow.count;
+  }
+
+  return {
+    totalProjects,
+    totalEntries,
+    entriesInProject,
+    totalSeats: 1,
+  };
+}
+
+/**
+ * Check if entry creation is allowed
+ * Returns { allowed: true } or { allowed: false, message: string }
+ */
+export async function checkEntryAllowed(
+  localDb: any,
+  projectId?: string
+): Promise<{ allowed: boolean; message?: string }> {
+  try {
+    const userId = getCurrentUserId();
+    const remoteDb = getRemoteDb();
+
+    const planId = await resolveUserPlan(localDb, remoteDb, userId);
+    const gate = new UsageGate(planId, () => getUsageCounts(localDb, userId, projectId));
+
+    const result = await gate.checkEntryCreate();
+
+    if (!result.allowed) {
+      return {
+        allowed: false,
+        message: `\n\n---\n💡 ${result.reason}\n${result.upgradeHint}`,
+      };
+    }
+
+    return { allowed: true };
+  } catch (error) {
+    // On error, allow the operation (fail open)
+    console.error('Usage gate error:', error);
+    return { allowed: true };
+  }
+}
+
+/**
+ * Check if a feature is enabled
+ * Returns { allowed: true } or { allowed: false, message: string }
+ */
+export async function checkFeatureAllowed(
+  localDb: any,
+  feature: 'semanticSearchEnabled' | 'smartSuggestEnabled' | 'branchingEnabled'
+): Promise<{ allowed: boolean; message?: string }> {
+  try {
+    const userId = getCurrentUserId();
+    const remoteDb = getRemoteDb();
+
+    const planId = await resolveUserPlan(localDb, remoteDb, userId);
+    const gate = new UsageGate(planId, () => getUsageCounts(localDb, userId));
+
+    const result = gate.checkFeature(feature);
+
+    if (!result.allowed) {
+      return {
+        allowed: false,
+        message: `\n\n---\n💡 ${result.reason}\n${result.upgradeHint}`,
+      };
+    }
+
+    return { allowed: true };
+  } catch (error) {
+    // On error, allow the operation (fail open)
+    console.error('Feature gate error:', error);
+    return { allowed: true };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/server.ts'],
+  format: ['esm'],
+  dts: false,
+  sourcemap: true,
+  clean: true,
+  splitting: false,
+  shims: true,
+});