memax-cli 0.1.0-alpha.4 → 0.1.0-alpha.40

package/src/commands/mcp.ts

@@ -1,357 +0,0 @@
-import { Command } from "commander";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import { apiGet, apiPost } from "../lib/api.js";
-
-interface RecallResult {
-  notes: Array<{
-    id: string;
-    title: string;
-    chunk_content: string;
-    heading_chain: string;
-    relevance_score: number;
-    category: string;
-    source: string;
-    age: string;
-  }>;
-  query_metadata: {
-    intent: string;
-    total_candidates: number;
-    latency_ms: number;
-  };
-}
-
-interface NoteResult {
-  id: string;
-  title: string;
-  category: string;
-  source: string;
-  tags: string[];
-  summary: string;
-  created_at: string;
-}
-
-function createServer(): Server {
-  const server = new Server(
-    { name: "memax", version: "0.0.1" },
-    { capabilities: { tools: {} } },
-  );
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-      {
-        name: "memax_recall",
-        description:
-          "Search the user's Memax knowledge base with a natural language query. " +
-          "Returns relevant memories ranked by relevance. Use this when you need " +
-          "background information about the project, team processes, or past decisions.",
-        inputSchema: {
-          type: "object" as const,
-          properties: {
-            query: {
-              type: "string",
-              description: "Natural language search query",
-            },
-            limit: {
-              type: "number",
-              description: "Max results to return (default 5)",
-            },
-            category: {
-              type: "string",
-              description:
-                "Filter by category prefix (e.g. 'core', 'decisions', 'process')",
-            },
-          },
-          required: ["query"],
-        },
-      },
-      {
-        name: "memax_push",
-        description:
-          "Save a piece of knowledge to the user's Memax knowledge base. " +
-          "Auto-categorized by AI if no category is provided.",
-        inputSchema: {
-          type: "object" as const,
-          properties: {
-            content: {
-              type: "string",
-              description: "The knowledge content to save",
-            },
-            title: {
-              type: "string",
-              description: "Optional title (auto-generated if omitted)",
-            },
-            category: {
-              type: "string",
-              description:
-                "Category (e.g. 'decisions/adr', 'core/architecture'). Auto-detected if omitted.",
-            },
-            tags: {
-              type: "array",
-              items: { type: "string" },
-              description: "Tags for the memory",
-            },
-          },
-          required: ["content"],
-        },
-      },
-      {
-        name: "memax_get",
-        description:
-          "Get the full content of a specific note by ID. " +
-          "Use this after memax_recall to read the complete content of a relevant memory.",
-        inputSchema: {
-          type: "object" as const,
-          properties: {
-            id: {
-              type: "string",
-              description:
-                "The note ID (from memax_recall or memax_search results)",
-            },
-          },
-          required: ["id"],
-        },
-      },
-      {
-        name: "memax_search",
-        description:
-          "List notes filtered by category or tags. " +
-          "For browsing and structured lookups, not semantic search. " +
-          "Use memax_recall for natural language queries instead.",
-        inputSchema: {
-          type: "object" as const,
-          properties: {
-            category: {
-              type: "string",
-              description: "Filter by category prefix",
-            },
-            limit: {
-              type: "number",
-              description: "Max results to return (default 10)",
-            },
-          },
-        },
-      },
-    ],
-  }));
-
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-
-    switch (name) {
-      case "memax_recall": {
-        const typedArgs = args as {
-          query: string;
-          limit?: number;
-          category?: string;
-        };
-        try {
-          const result = await apiPost<RecallResult>("/v1/recall", {
-            query: typedArgs.query,
-            limit: typedArgs.limit ?? 5,
-            category: typedArgs.category ?? "",
-            source: "mcp",
-            working_dir: process.cwd(),
-          });
-
-          const notes = result.notes ?? [];
-          if (notes.length === 0) {
-            return {
-              content: [{ type: "text" as const, text: "No results found." }],
-            };
-          }
-
-          const formatted = notes
-            .map((n, i) => {
-              const score = (n.relevance_score * 100).toFixed(0);
-              const heading = n.heading_chain ? ` — ${n.heading_chain}` : "";
-              return (
-                `[${i + 1}] ${n.title} [${n.category}, ${score}%, ${n.age}] (id: ${n.id})${heading}\n` +
-                n.chunk_content
-              );
-            })
-            .join("\n\n");
-
-          return { content: [{ type: "text" as const, text: formatted }] };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Recall failed: ${(err as Error).message}`,
-              },
-            ],
-            isError: true,
-          };
-        }
-      }
-
-      case "memax_push": {
-        const typedArgs = args as {
-          content: string;
-          title?: string;
-          category?: string;
-          tags?: string[];
-        };
-        try {
-          const note = await apiPost<NoteResult>("/v1/notes", {
-            content: typedArgs.content,
-            title: typedArgs.title ?? "",
-            category: typedArgs.category ?? "",
-            tags: typedArgs.tags ?? [],
-            source: "mcp",
-          });
-
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Saved: ${note.title} (id: ${note.id})`,
-              },
-            ],
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Push failed: ${(err as Error).message}`,
-              },
-            ],
-            isError: true,
-          };
-        }
-      }
-
-      case "memax_get": {
-        const typedArgs = args as { id: string };
-        try {
-          const note = await apiGet<{
-            id: string;
-            title: string;
-            content: string;
-            summary: string;
-            category: string;
-            tags: string[];
-            source: string;
-            source_path: string;
-            created_at: string;
-            updated_at: string;
-          }>(`/v1/notes/${typedArgs.id}`);
-
-          const parts = [
-            `# ${note.title}`,
-            `Category: ${note.category} | Source: ${note.source} | Created: ${note.created_at}`,
-          ];
-          if (note.tags?.length > 0) {
-            parts.push(`Tags: ${note.tags.join(", ")}`);
-          }
-          if (note.source_path) {
-            parts.push(`Source: ${note.source_path}`);
-          }
-          if (note.summary) {
-            parts.push(`\n## Summary\n${note.summary}`);
-          }
-          parts.push(`\n## Content\n${note.content}`);
-
-          return {
-            content: [{ type: "text" as const, text: parts.join("\n") }],
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Get failed: ${(err as Error).message}`,
-              },
-            ],
-            isError: true,
-          };
-        }
-      }
-
-      case "memax_search": {
-        const typedArgs = args as {
-          category?: string;
-          limit?: number;
-        };
-        try {
-          const notes = (await apiGet<NoteResult[]>("/v1/notes")) ?? [];
-
-          let filtered = notes;
-          if (typedArgs.category) {
-            filtered = notes.filter((n) =>
-              n.category.startsWith(typedArgs.category!),
-            );
-          }
-
-          const limited = filtered.slice(0, typedArgs.limit ?? 10);
-
-          if (limited.length === 0) {
-            return {
-              content: [{ type: "text" as const, text: "No notes found." }],
-            };
-          }
-
-          const formatted = limited
-            .map(
-              (n) => `- ${n.title} [${n.category}] — ${n.source} (id: ${n.id})`,
-            )
-            .join("\n");
-
-          return { content: [{ type: "text" as const, text: formatted }] };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Search failed: ${(err as Error).message}`,
-              },
-            ],
-            isError: true,
-          };
-        }
-      }
-
-      default:
-        return {
-          content: [{ type: "text" as const, text: `Unknown tool: ${name}` }],
-          isError: true,
-        };
-    }
-  });
-
-  return server;
-}
-
-async function mcpServeCommand(): Promise<void> {
-  const server = createServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-
-  // Keep the process alive — some agent launchers close stdin early
-  // which makes Node think the event loop is empty and exit.
-  await new Promise<void>((resolve) => {
-    process.on("SIGINT", resolve);
-    process.on("SIGTERM", resolve);
-    // Also resolve if stdin closes (transport disconnected)
-    process.stdin.on("end", resolve);
-  });
-
-  await server.close();
-}
-
-export function registerMcpCommand(program: Command): void {
-  const mcp = program
-    .command("mcp")
-    .description("Model Context Protocol server for AI agents");
-
-  mcp
-    .command("serve")
-    .description("Start MCP server on stdio")
-    .action(mcpServeCommand);
-}

package/src/commands/push.ts

@@ -1,82 +0,0 @@
-import chalk from "chalk";
-import { readFileSync } from "node:fs";
-import { basename } from "node:path";
-import { apiPost } from "../lib/api.js";
-import type { Note } from "@memaxlabs/shared";
-
-interface PushOptions {
-  file?: string;
-  category?: string;
-  tags?: string;
-  ttl?: string;
-  stdin?: boolean;
-  title?: string;
-}
-
-export async function pushCommand(options: PushOptions): Promise<void> {
-  let content: string;
-  let title = options.title ?? "";
-  let sourcePath = "";
-
-  if (options.file) {
-    try {
-      content = readFileSync(options.file, "utf-8");
-      sourcePath = options.file;
-      if (!title) {
-        title = basename(options.file);
-      }
-    } catch (err) {
-      console.error(chalk.red(`Error reading file: ${options.file}`));
-      process.exit(1);
-    }
-  } else if (options.stdin || !process.stdin.isTTY) {
-    const chunks: Buffer[] = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    content = Buffer.concat(chunks).toString("utf-8");
-  } else {
-    console.error(chalk.red("Provide --file <path> or pipe content via stdin"));
-    process.exit(1);
-  }
-
-  if (!content.trim()) {
-    console.error(chalk.red("No content to push"));
-    process.exit(1);
-  }
-
-  const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
-
-  // Auto-detect URL content: single-line http(s) URL -> content_type "link"
-  const trimmed = content.trim();
-  const isURL =
-    (trimmed.startsWith("http://") || trimmed.startsWith("https://")) &&
-    !trimmed.includes("\n");
-
-  let contentType = sourcePath.endsWith(".md") ? "markdown" : "text";
-  if (isURL) {
-    contentType = "link";
-  }
-
-  try {
-    const note = await apiPost<Note>("/v1/notes", {
-      content,
-      title,
-      category: options.category ?? "",
-      tags,
-      source: "cli",
-      source_path: sourcePath,
-      content_type: contentType,
-    });
-
-    console.log(chalk.green("Saved"), chalk.bold(note.title));
-    console.log(
-      chalk.gray(
-        `  id: ${note.id}  category: ${note.category}  source: ${note.source}`,
-      ),
-    );
-  } catch (err) {
-    console.error(chalk.red(`Push failed: ${(err as Error).message}`));
-    process.exit(1);
-  }
-}

package/src/commands/recall.ts

@@ -1,163 +0,0 @@
-import chalk from "chalk";
-import { apiPost } from "../lib/api.js";
-
-interface RecallResult {
-  notes: Array<{
-    id: string;
-    title: string;
-    chunk_content: string;
-    heading_chain: string;
-    relevance_score: number;
-    category: string;
-    source: string;
-    age: string;
-  }>;
-  query_metadata: {
-    intent: string;
-    total_candidates: number;
-    latency_ms: number;
-  };
-}
-
-interface RecallOptions {
-  category?: string;
-  tags?: string;
-  limit?: string;
-  format?: string;
-  includeArchived?: boolean;
-  hook?: boolean;
-  maxTokens?: string;
-}
-
-export async function recallCommand(
-  query: string | undefined,
-  options: RecallOptions,
-): Promise<void> {
-  if (!query) {
-    // Read from stdin if no query argument
-    if (!process.stdin.isTTY) {
-      const chunks: Buffer[] = [];
-      for await (const chunk of process.stdin) {
-        chunks.push(chunk);
-      }
-      query = Buffer.concat(chunks).toString("utf-8").trim();
-    }
-    if (!query) {
-      console.error(chalk.red('Provide a query: memax recall "your question"'));
-      process.exit(1);
-    }
-  }
-
-  const limit = parseInt(options.limit ?? "5", 10);
-
-  try {
-    const result = await apiPost<RecallResult>("/v1/recall", {
-      query,
-      category: options.category ?? "",
-      limit,
-      include_archived: options.includeArchived ?? false,
-      source: options.hook ? "hook" : "cli",
-      working_dir: process.cwd(),
-    });
-
-    const notes = result.notes ?? [];
-
-    if (options.format === "json") {
-      console.log(JSON.stringify({ ...result, notes }, null, 2));
-      return;
-    }
-
-    // Hook mode: output clean context for agent injection
-    if (options.hook) {
-      if (notes.length === 0) return;
-      let output = "<memax-context>\n";
-      output += "## Relevant Context (from Memax)\n\n";
-      for (const note of notes) {
-        const heading = note.heading_chain ? ` — ${note.heading_chain}` : "";
-        output += `### ${note.title} [${note.category}, ${note.age}]${heading}\n`;
-        output += note.chunk_content + "\n\n";
-      }
-      output += "</memax-context>";
-
-      // Truncate to fit within token budget (1 token ≈ 4 characters)
-      const maxTokens = options.maxTokens
-        ? parseInt(options.maxTokens, 10)
-        : undefined;
-      if (maxTokens) {
-        const maxChars = maxTokens * 4;
-        if (output.length > maxChars) {
-          output =
-            output.substring(0, maxChars - 50) +
-            "\n\n[truncated to fit token budget]\n</memax-context>";
-        }
-      }
-
-      console.log(output);
-      return;
-    }
-
-    // Pipe-friendly plain text output when stdout is not a TTY
-    if (!process.stdout.isTTY) {
-      if (notes.length === 0) {
-        return;
-      }
-      for (const note of notes) {
-        const score = (note.relevance_score * 100).toFixed(0);
-        console.log(
-          `${note.title} [${note.category}] ${score}% · ${note.age} (${note.id})`,
-        );
-        if (note.heading_chain) {
-          console.log(`  ${note.heading_chain}`);
-        }
-        const lines = note.chunk_content.split("\n").slice(0, 3);
-        for (const line of lines) {
-          console.log(`  ${line}`);
-        }
-        console.log();
-      }
-      return;
-    }
-
-    // Human-readable output
-    if (notes.length === 0) {
-      console.log(chalk.yellow("No results found."));
-      console.log(
-        chalk.gray(
-          `  Searched ${result.query_metadata.total_candidates} chunks in ${result.query_metadata.latency_ms}ms`,
-        ),
-      );
-      return;
-    }
-
-    console.log(
-      chalk.blue(`${notes.length} result${notes.length > 1 ? "s" : ""}`),
-      chalk.gray(
-        `(${result.query_metadata.total_candidates} chunks searched, ${result.query_metadata.latency_ms}ms)`,
-      ),
-    );
-    console.log();
-
-    for (const note of notes) {
-      const score = (note.relevance_score * 100).toFixed(0);
-      console.log(
-        chalk.bold(note.title),
-        chalk.gray(`[${note.category}]`),
-        chalk.cyan(`${score}%`),
-        chalk.gray(`· ${note.age}`),
-      );
-      console.log(chalk.gray(`  id: ${note.id}`));
-      if (note.heading_chain) {
-        console.log(chalk.gray(`  ${note.heading_chain}`));
-      }
-      // Show first 3 lines of chunk content
-      const lines = note.chunk_content.split("\n").slice(0, 3);
-      for (const line of lines) {
-        console.log(chalk.white(`  ${line}`));
-      }
-      console.log();
-    }
-  } catch (err) {
-    console.error(chalk.red(`Recall failed: ${(err as Error).message}`));
-    process.exit(1);
-  }
-}