@memoraone/mcp 0.1.0

package/dist/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/* eslint-env node */
+/* global console, process */
+// CLI entrypoint for npx @memoraone/mcp
+import './index.js';

package/dist/client/memoraClient.js

@@ -0,0 +1,44 @@
+//packages/mcp/src/client/memoraClient.ts
+import { fetch } from 'undici';
+export class MemoraOneHttpError extends Error {
+    constructor(status, statusText, body) {
+        super(`MemoraOne request failed: ${status} ${statusText}`);
+        this.name = 'MemoraOneHttpError';
+        this.status = status;
+        this.body = body;
+    }
+}
+export class MemoraClient {
+    constructor(cfg) {
+        this.baseUrl = cfg.apiUrl;
+        this.projectId = cfg.projectId;
+        this.apiKey = cfg.apiKey;
+    }
+    async post(path, body) {
+        const url = `${this.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+        process.stderr.write(`[memoraone-mcp] http url=${url} projectId=${this.projectId} apiKeyPrefix=${String(this.apiKey).slice(0, 8)} apiKeyLen=${String(this.apiKey).length}\n`);
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'x-api-key': this.apiKey,
+                'x-memora-project-id': this.projectId,
+            },
+            body: JSON.stringify(body ?? {}),
+        });
+        const text = await res.text();
+        const parsedBody = (() => {
+            try {
+                return text ? JSON.parse(text) : null;
+            }
+            catch {
+                return text;
+            }
+        })();
+        if (!res.ok) {
+            throw new MemoraOneHttpError(res.status, res.statusText, parsedBody);
+        }
+        return parsedBody;
+    }
+}
+export default MemoraClient;

package/dist/config.js

@@ -0,0 +1,69 @@
+//packages/mcp/src/config.ts
+import * as process from 'node:process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { z } from 'zod/v4';
+const dotenvPath = path.resolve(process.cwd(), '.env');
+if (fs.existsSync(dotenvPath)) {
+    try {
+        const { config: loadDotEnv } = await import('dotenv');
+        loadDotEnv({ path: dotenvPath });
+    }
+    catch (err) {
+        process.stderr.write('[memoraone-mcp] Failed to load .env: ' + String(err) + '\n');
+    }
+}
+const EnvSchema = z.object({
+    MEMORAONE_API_URL: z.string().url(),
+    MEMORAONE_PROJECT_ID: z.string().min(1),
+    MEMORAONE_API_KEY: z.string().min(1),
+    MEMORAONE_AGENT_NAME: z.string().min(1).optional(),
+    MEMORAONE_AGENT_TYPE: z.string().min(1).optional(),
+    MEMORAONE_SOURCE: z.string().min(1).optional(),
+    MEMORAONE_WORKLOG: z.string().min(1).optional(),
+    MEMORAONE_HEARTBEAT: z.string().min(1).optional(),
+    MEMORAONE_HEARTBEAT_INTERVAL_MS: z.string().min(1).optional(),
+});
+const requiredEnvVars = [
+    'MEMORAONE_API_URL',
+    'MEMORAONE_PROJECT_ID',
+    'MEMORAONE_API_KEY',
+];
+const missingEnvVars = requiredEnvVars.filter((key) => {
+    const value = process.env[key];
+    return value === undefined || value.trim() === '';
+});
+if (missingEnvVars.length > 0) {
+    process.stderr.write(`[memoraone-mcp] Missing required environment variables: ${missingEnvVars.join(', ')}\n`);
+    process.exit(1);
+}
+const parsed = EnvSchema.safeParse(process.env);
+if (!parsed.success) {
+    const formatted = parsed.error.format();
+    process.stderr.write('[memoraone-mcp] Invalid environment variables ' + JSON.stringify(formatted) + '\n');
+    throw new Error('Config validation failed');
+}
+const parseBooleanFlag = (value, defaultValue) => {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized)) {
+        return true;
+    }
+    if (['0', 'false', 'no', 'off'].includes(normalized)) {
+        return false;
+    }
+    return defaultValue;
+};
+export const config = {
+    apiUrl: parsed.data.MEMORAONE_API_URL.replace(/\/+$/, ''),
+    projectId: parsed.data.MEMORAONE_PROJECT_ID,
+    apiKey: parsed.data.MEMORAONE_API_KEY,
+    agentName: parsed.data.MEMORAONE_AGENT_NAME ?? 'cursor',
+    agentType: parsed.data.MEMORAONE_AGENT_TYPE ?? 'agent',
+    source: parsed.data.MEMORAONE_SOURCE ?? 'cursor',
+    worklogEnabled: parseBooleanFlag(parsed.data.MEMORAONE_WORKLOG, true),
+    heartbeatEnabled: parseBooleanFlag(parsed.data.MEMORAONE_HEARTBEAT, true),
+    heartbeatIntervalMs: Number.parseInt(parsed.data.MEMORAONE_HEARTBEAT_INTERVAL_MS ?? '30000', 10),
+};

package/dist/index.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/* eslint-env node */
+/* global console, process */
+// packages/mcp/src/index.ts
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { config } from './config.js';
+import MemoraClient from './client/memoraClient.js';
+import { postEventShape } from './tools/postEvent.js';
+import { askWithMemoryShape } from './tools/askWithMemory.js';
+import { logIntentShape } from './tools/logIntent.js';
+import { logChangeSummaryShape } from './tools/logChangeSummary.js';
+import { logToolResultShape } from './tools/logToolResult.js';
+import { logCommandShape } from './tools/logCommand.js';
+import { handlePostEvent } from './tools/handlers/postEvent.js';
+import { handleAskWithMemory } from './tools/handlers/askWithMemory.js';
+import { handleLogIntent } from './tools/handlers/logIntent.js';
+import { handleLogChangeSummary } from './tools/handlers/logChangeSummary.js';
+import { handleLogToolResult } from './tools/handlers/logToolResult.js';
+import { handleLogCommand } from './tools/handlers/logCommand.js';
+async function sendHeartbeat(client) {
+    try {
+        await client.post('/admin/api-keys/heartbeat', {});
+    }
+    catch (err) {
+        console.error('[memoraone-mcp] heartbeat error (silent)', err);
+    }
+}
+function redactSensitiveFields(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(redactSensitiveFields);
+    }
+    const redacted = {};
+    const sensitiveKeys = /^(headers?|api[_-]?key|token|cookie|authorization|auth|password|secret|credential|bearer)$/i;
+    for (const [key, value] of Object.entries(obj)) {
+        if (sensitiveKeys.test(key)) {
+            redacted[key] = '[REDACTED]';
+        }
+        else if (typeof value === 'object') {
+            redacted[key] = redactSensitiveFields(value);
+        }
+        else {
+            redacted[key] = value;
+        }
+    }
+    return redacted;
+}
+function sanitizeArgsSummary(args) {
+    try {
+        const redacted = redactSensitiveFields(args);
+        const summary = JSON.stringify(redacted);
+        return summary.length > 200 ? summary.slice(0, 200) + '...' : summary;
+    }
+    catch {
+        return '[unable to serialize args]';
+    }
+}
+async function postWorklogEvent(client, message) {
+    try {
+        const body = {
+            kind: 'note',
+            concept: 'concept:worklog',
+            actor: { type: config.agentType, name: config.agentName },
+            message,
+            metadata: {
+                source: config.source,
+                purpose: 'worklog',
+            },
+        };
+        await client.post('/timeline/events', body);
+    }
+    catch (err) {
+        console.error('[memoraone-mcp] worklog error (silent)', err);
+    }
+}
+function registerToolWithWorklog(server, client, toolName, description, schema, handler) {
+    if (!config.worklogEnabled) {
+        server.tool(toolName, description, schema, handler);
+        return;
+    }
+    server.tool(toolName, description, schema, async (args) => {
+        const argsSummary = sanitizeArgsSummary(args);
+        const start = Date.now();
+        await postWorklogEvent(client, `tool_start: ${toolName} ${argsSummary}`);
+        try {
+            const result = await handler(args);
+            const durationMs = Date.now() - start;
+            await postWorklogEvent(client, `tool_end: ${toolName} ok (${durationMs}ms)`);
+            return result;
+        }
+        catch (err) {
+            const durationMs = Date.now() - start;
+            const errorSummary = err?.message || String(err);
+            const shortError = errorSummary.length > 100 ? errorSummary.slice(0, 100) + '...' : errorSummary;
+            await postWorklogEvent(client, `tool_end: ${toolName} error (${durationMs}ms): ${shortError}`);
+            throw err;
+        }
+    });
+}
+async function main() {
+    const client = new MemoraClient(config);
+    // Log agent identity (no secrets)
+    console.error(`[memoraone-mcp] Agent identity: name="${config.agentName}", type="${config.agentType}", source="${config.source}"`);
+    const server = new McpServer({
+        name: 'memoraone-vscode-mcp',
+        version: '1.0.0',
+    });
+    // Track tool names for diagnostic logging
+    const registeredToolNames = [];
+    // ---- memora_post_event ----
+    registeredToolNames.push('memora_post_event');
+    registerToolWithWorklog(server, client, 'memora_post_event', 'Forward an event to MemoraOne timeline', postEventShape, async (args) => {
+        const result = await handlePostEvent(client, args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    });
+    // ---- memora_ask_with_memory ----
+    registeredToolNames.push('memora_ask_with_memory');
+    registerToolWithWorklog(server, client, 'memora_ask_with_memory', 'Ask MemoraOne with project memory context', askWithMemoryShape, async (args) => {
+        const result = await handleAskWithMemory(client, args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    });
+    // ---- memora_log_intent ----
+    registeredToolNames.push('memora_log_intent');
+    registerToolWithWorklog(server, client, 'memora_log_intent', 'Log a natural-language TASK or DECISION intent to the MemoraOne timeline', logIntentShape, async (args) => {
+        const result = await handleLogIntent(client, args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    });
+    // ---- memora_log_change_summary ----
+    registeredToolNames.push('memora_log_change_summary');
+    registerToolWithWorklog(server, client, 'memora_log_change_summary', 'Log a concise code change summary to the MemoraOne timeline', logChangeSummaryShape, async (args) => {
+        const result = await handleLogChangeSummary(client, args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    });
+    // ---- memora_log_tool_result ----
+    registeredToolNames.push('memora_log_tool_result');
+    registerToolWithWorklog(server, client, 'memora_log_tool_result', 'Log a tool execution result to the MemoraOne timeline', logToolResultShape, async (args) => {
+        const result = await handleLogToolResult(client, args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    });
+    // ---- memora_log_command ----
+    registeredToolNames.push('memora_log_command');
+    registerToolWithWorklog(server, client, 'memora_log_command', 'Log a command execution to the MemoraOne timeline', logCommandShape, async (args) => {
+        const result = await handleLogCommand(client, args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    });
+    console.error('[memoraone-vscode-mcp] Starting MCP server with', registeredToolNames.length, 'tools');
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    let heartbeatInterval = null;
+    if (config.heartbeatEnabled) {
+        if (globalThis.__memoraHeartbeatInterval) {
+            clearInterval(globalThis.__memoraHeartbeatInterval);
+        }
+        await sendHeartbeat(client);
+        const intervalMs = Number.isFinite(config.heartbeatIntervalMs)
+            ? Math.max(1000, config.heartbeatIntervalMs)
+            : 30000;
+        heartbeatInterval = setInterval(() => {
+            sendHeartbeat(client).catch(() => {
+                // Errors already logged in sendHeartbeat
+            });
+        }, intervalMs);
+        globalThis.__memoraHeartbeatInterval = heartbeatInterval;
+    }
+    const shutdown = (signal) => {
+        if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+        }
+        if (globalThis.__memoraHeartbeatInterval) {
+            clearInterval(globalThis.__memoraHeartbeatInterval);
+        }
+        console.error(`[memoraone-vscode-mcp] Received ${signal}, shutting down`);
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    console.error('[memoraone-vscode-mcp] MCP server ready');
+}
+main().catch((err) => {
+    console.error('[memoraone-vscode-mcp] fatal error', err);
+    process.exit(1);
+});

package/dist/runContext.js

@@ -0,0 +1,18 @@
+// packages/mcp/src/runContext.ts
+import { randomUUID } from 'crypto';
+let currentRunId = null;
+export function getCurrentRunId() {
+    return currentRunId;
+}
+export function setCurrentRunId(id) {
+    currentRunId = id;
+}
+export function resolveRunId(passed) {
+    if (passed) {
+        return passed;
+    }
+    return currentRunId;
+}
+export function generateRunId() {
+    return randomUUID();
+}

package/dist/tools/askWithMemory.js

@@ -0,0 +1,12 @@
+//memoraone/adapters/vscode-mcp/src/tools/askWithMemory.ts
+import { z } from 'zod/v4';
+export const askWithMemoryShape = {
+    question: z.string().min(1),
+    code_context: z
+        .object({
+        file_path: z.string().optional(),
+        selected_text: z.string().optional(),
+        language: z.string().optional(),
+    })
+        .optional(),
+};

package/dist/tools/handlers/askWithMemory.js

@@ -0,0 +1,38 @@
+//memoraone/adapters/vscode-mcp/src/tools/handlers/askWithMemory.ts
+import { z } from 'zod/v4';
+const askWithMemoryInputSchema = z.object({
+    question: z.string().min(1),
+    code_context: z
+        .object({
+        file_path: z.string().optional(),
+        selected_text: z.string().optional(),
+        language: z.string().optional(),
+    })
+        .optional(),
+});
+function isAskWithMemoryResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.answer === 'string' &&
+        value.answer !== '');
+}
+export async function handleAskWithMemory(client, args) {
+    const parsed = askWithMemoryInputSchema.parse(args ?? {});
+    const payload = {
+        question: parsed.question,
+    };
+    if (parsed.code_context) {
+        payload.code_context = parsed.code_context;
+    }
+    const res = await client.post('/agent/ask-with-memory', payload);
+    if (!isAskWithMemoryResponse(res)) {
+        const err = new Error('Unexpected response from MemoraOne');
+        err.status = 502;
+        err.body = res;
+        throw err;
+    }
+    return {
+        answer: res.answer,
+        used: res.used ?? {},
+    };
+}

package/dist/tools/handlers/logChangeSummary.js

@@ -0,0 +1,44 @@
+//packages/mcp/src/tools/handlers/logChangeSummary.ts
+import { z } from 'zod/v4';
+import { resolveRunId } from '../../runContext.js';
+import { config } from '../../config.js';
+const logChangeSummaryInputSchema = z.object({
+    summary: z.string().min(1),
+    scope: z.string().min(1).optional(),
+    files: z.array(z.string().min(1)).optional(),
+    stats: z
+        .object({
+        files: z.number().int().nonnegative().optional(),
+        add: z.number().int().nonnegative().optional(),
+        del: z.number().int().nonnegative().optional(),
+    })
+        .optional(),
+    commit: z.string().min(1).optional(),
+    run_id: z.string().min(1).optional(),
+});
+export async function handleLogChangeSummary(client, args) {
+    const parsed = logChangeSummaryInputSchema.parse(args ?? {});
+    const { summary, scope, files, stats, commit } = parsed;
+    const message = summary.startsWith('CHANGE:')
+        ? summary
+        : `CHANGE: ${scope ?? 'code'} — ${summary}`;
+    const run_id = resolveRunId(parsed.run_id);
+    const body = {
+        kind: 'note',
+        concept: 'concept:change_summary',
+        actor: { type: config.agentType, name: config.agentName },
+        message,
+        metadata: {
+            source: config.source,
+            purpose: 'change_summary',
+            tool: 'memora_log_change_summary',
+            ...(scope ? { scope } : {}),
+            ...(files ? { files } : {}),
+            ...(stats ? { stats } : {}),
+            ...(commit ? { commit } : {}),
+            ...(run_id ? { run_id } : {}),
+        },
+    };
+    await client.post('/timeline/events', body);
+    return { ok: true };
+}

package/dist/tools/handlers/logCommand.js

@@ -0,0 +1,40 @@
+//packages/mcp/src/tools/handlers/logCommand.ts
+import { z } from 'zod/v4';
+import { resolveRunId } from '../../runContext.js';
+import { config } from '../../config.js';
+const logCommandInputSchema = z.object({
+    cmd: z.string().min(1),
+    summary: z.string().min(1),
+    cwd: z.string().min(1).optional(),
+    exit_code: z.number().int().optional(),
+    duration_ms: z.number().int().nonnegative().optional(),
+    run_id: z.string().min(1).optional(),
+    stats: z.record(z.string(), z.any()).optional(),
+});
+export async function handleLogCommand(client, args) {
+    const parsed = logCommandInputSchema.parse(args ?? {});
+    const { cmd, summary, cwd, exit_code, duration_ms, stats } = parsed;
+    const message = summary.startsWith('COMMAND:')
+        ? summary
+        : `COMMAND: ${cmd} — ${summary}`;
+    const run_id = resolveRunId(parsed.run_id);
+    const body = {
+        kind: 'note',
+        concept: 'concept:command',
+        actor: { type: config.agentType, name: config.agentName },
+        message,
+        metadata: {
+            source: config.source,
+            purpose: 'command',
+            tool: 'memora_log_command',
+            cmd,
+            ...(cwd ? { cwd } : {}),
+            ...(exit_code !== undefined ? { exit_code } : {}),
+            ...(duration_ms !== undefined ? { duration_ms } : {}),
+            ...(run_id ? { run_id } : {}),
+            ...(stats ? { stats } : {}),
+        },
+    };
+    await client.post('/timeline/events', body);
+    return { ok: true };
+}

package/dist/tools/handlers/logIntent.js

@@ -0,0 +1,42 @@
+//packages/mcp/src/tools/handlers/logIntent.ts
+import { z } from 'zod/v4';
+import { generateRunId, setCurrentRunId } from '../../runContext.js';
+import { config } from '../../config.js';
+const logIntentInputSchema = z.object({
+    intent: z.enum(['task', 'decision']),
+    message: z.string().min(1),
+    context: z.record(z.string(), z.any()).optional(),
+    intent_source: z.string().optional().default('cursor_chat'),
+    run_id: z.string().min(1).optional(),
+});
+export async function handleLogIntent(client, args) {
+    const parsed = logIntentInputSchema.parse(args ?? {});
+    const intent = parsed.intent;
+    const message = parsed.message.trim();
+    if (!message) {
+        throw new Error('message cannot be empty after trimming');
+    }
+    const intent_source = parsed.intent_source ?? 'cursor_chat';
+    const context = parsed.context;
+    const purpose = intent; // 'task' | 'decision'
+    const concept = purpose === 'task' ? 'concept:task' : 'concept:decision';
+    // Determine run_id: use provided or generate new one
+    const run_id = parsed.run_id ?? generateRunId();
+    // Set current run_id when purpose is task or decision
+    setCurrentRunId(run_id);
+    const body = {
+        kind: 'note',
+        actor: { type: config.agentType, name: config.agentName },
+        concept, // MUST be TOP-LEVEL so it populates timeline_events.concept
+        message,
+        metadata: {
+            source: config.source,
+            purpose, // 'task' | 'decision'
+            intent_source: intent_source ?? 'cursor_chat',
+            run_id,
+            ...(context ? { context } : {}),
+        },
+    };
+    await client.post('/timeline/events', body);
+    return { ok: true, run_id };
+}

package/dist/tools/handlers/logToolResult.js

@@ -0,0 +1,44 @@
+//packages/mcp/src/tools/handlers/logToolResult.ts
+import { z } from 'zod/v4';
+import { resolveRunId } from '../../runContext.js';
+import { config } from '../../config.js';
+const logToolResultInputSchema = z.object({
+    tool: z.string().min(1),
+    status: z.enum(['ok', 'error', 'partial']),
+    summary: z.string().min(1),
+    run_id: z.string().min(1).optional(),
+    duration_ms: z.number().int().nonnegative().optional(),
+    error_code: z.string().min(1).optional(),
+    error_message: z.string().min(1).optional(),
+    error_kind: z.enum(['infra', 'logic', 'auth', 'rate_limit', 'validation', 'unknown']).optional(),
+    stats: z.record(z.string(), z.any()).optional(),
+});
+export async function handleLogToolResult(client, args) {
+    const parsed = logToolResultInputSchema.parse(args ?? {});
+    const { tool, status, summary, duration_ms, error_code, error_message, error_kind, stats } = parsed;
+    const message = summary.startsWith('RESULT:')
+        ? summary
+        : `RESULT: ${tool} — ${status} — ${summary}`;
+    const run_id = resolveRunId(parsed.run_id);
+    const body = {
+        kind: 'note',
+        concept: 'concept:tool_result',
+        actor: { type: config.agentType, name: config.agentName },
+        message,
+        metadata: {
+            source: config.source,
+            purpose: 'tool_result',
+            tool: 'memora_log_tool_result',
+            tool_name: tool,
+            status,
+            ...(run_id ? { run_id } : {}),
+            ...(duration_ms ? { duration_ms } : {}),
+            ...(error_code ? { error_code } : {}),
+            ...(error_message ? { error_message } : {}),
+            ...(error_kind ? { error_kind } : {}),
+            ...(stats ? { stats } : {}),
+        },
+    };
+    await client.post('/timeline/events', body);
+    return { ok: true };
+}

package/dist/tools/handlers/postEvent.js

@@ -0,0 +1,23 @@
+//packages/mcp/src/tools/handlers/postEvent.ts
+import { z } from 'zod/v4';
+import { config } from '../../config.js';
+const postEventInputSchema = z.object({
+    kind: z.string().min(1),
+    actor: z.object({ identifier: z.string().min(1) }),
+    content: z.record(z.string(), z.any()),
+    metadata: z.record(z.string(), z.any()).optional(),
+});
+export async function handlePostEvent(client, args) {
+    const parsed = postEventInputSchema.parse(args ?? {});
+    const body = {
+        kind: parsed.kind,
+        actor: { type: config.agentType, identifier: parsed.actor.identifier },
+        content: parsed.content,
+        metadata: {
+            source: config.source,
+            ...parsed.metadata,
+        },
+    };
+    await client.post('/timeline/events', body);
+    return { ok: true, forwarded: true };
+}

package/dist/tools/logChangeSummary.js

@@ -0,0 +1,16 @@
+//memoraone/adapters/vscode-mcp/src/tools/logChangeSummary.ts
+import { z } from 'zod/v4';
+export const logChangeSummaryShape = {
+    summary: z.string().min(1),
+    scope: z.string().min(1).optional(),
+    files: z.array(z.string().min(1)).optional(),
+    stats: z
+        .object({
+        files: z.number().int().nonnegative().optional(),
+        add: z.number().int().nonnegative().optional(),
+        del: z.number().int().nonnegative().optional(),
+    })
+        .optional(),
+    commit: z.string().min(1).optional(),
+    run_id: z.string().min(1).optional(),
+};

package/dist/tools/logCommand.js

@@ -0,0 +1,11 @@
+//memoraone/adapters/vscode-mcp/src/tools/logCommand.ts
+import { z } from 'zod/v4';
+export const logCommandShape = {
+    cmd: z.string().min(1),
+    summary: z.string().min(1),
+    cwd: z.string().min(1).optional(),
+    exit_code: z.number().int().optional(),
+    duration_ms: z.number().int().nonnegative().optional(),
+    run_id: z.string().min(1).optional(),
+    stats: z.record(z.string(), z.any()).optional(),
+};

package/dist/tools/logIntent.js

@@ -0,0 +1,9 @@
+//memoraone/adapters/vscode-mcp/src/tools/logIntent.ts
+import { z } from 'zod/v4';
+export const logIntentShape = {
+    intent: z.enum(['task', 'decision']),
+    message: z.string().min(1),
+    context: z.record(z.string(), z.any()).optional(),
+    intent_source: z.string().optional().default('cursor_chat'),
+    run_id: z.string().min(1).optional(),
+};

package/dist/tools/logToolResult.js

@@ -0,0 +1,13 @@
+//memoraone/adapters/vscode-mcp/src/tools/logToolResult.ts
+import { z } from 'zod/v4';
+export const logToolResultShape = {
+    tool: z.string().min(1),
+    status: z.enum(['ok', 'error', 'partial']),
+    summary: z.string().min(1),
+    run_id: z.string().min(1).optional(),
+    duration_ms: z.number().int().nonnegative().optional(),
+    error_code: z.string().min(1).optional(),
+    error_message: z.string().min(1).optional(),
+    error_kind: z.enum(['infra', 'logic', 'auth', 'rate_limit', 'validation', 'unknown']).optional(),
+    stats: z.record(z.string(), z.any()).optional(),
+};

package/dist/tools/postEvent.js

@@ -0,0 +1,8 @@
+//memoraone/adapters/vscode-mcp/src/tools/postEvent.ts
+import { z } from 'zod/v4';
+export const postEventShape = {
+    kind: z.string().min(1),
+    actor: z.object({ identifier: z.string().min(1) }),
+    content: z.record(z.string(), z.any()),
+    metadata: z.record(z.string(), z.any()).optional(),
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@memoraone/mcp",
+  "version": "0.1.0",
+  "type": "module",
+
+  "bin": {
+    "memoraone-mcp": "./dist/cli.js"
+  },
+
+  "files": [
+    "dist",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "lint": "eslint ."
+  },
+
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "dotenv": "^16.4.5",
+    "undici": "^7.16.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  }
+}