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

package/src/commands/sync.ts

@@ -1,403 +0,0 @@
-import chalk from "chalk";
-import {
-  readFileSync,
-  readdirSync,
-  statSync,
-  watch,
-  existsSync,
-} from "node:fs";
-import { join, relative, extname, resolve, basename } from "node:path";
-import { homedir } from "node:os";
-import { apiPost } from "../lib/api.js";
-import type { Note } from "@memaxlabs/shared";
-
-interface SyncOptions {
-  boundary?: string;
-  category?: string;
-  watch?: boolean;
-  ignore?: string;
-  agentMemory?: boolean;
-}
-
-const DEFAULT_IGNORE = new Set([
-  "node_modules",
-  ".git",
-  ".next",
-  "dist",
-  "__pycache__",
-  ".env",
-  ".env.local",
-  ".DS_Store",
-]);
-
-const SUPPORTED_EXTENSIONS = new Set([
-  ".md",
-  ".txt",
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".go",
-  ".py",
-  ".rs",
-  ".yaml",
-  ".yml",
-  ".json",
-  ".toml",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".css",
-  ".html",
-  ".sql",
-  ".graphql",
-  ".proto",
-  ".dockerfile",
-]);
-
-export async function syncAgentMemoryCommand(): Promise<void> {
-  await syncAgentMemory();
-}
-
-export async function syncCommand(
-  directory: string | undefined,
-  options: SyncOptions,
-): Promise<void> {
-  if (options.agentMemory || directory === "agents") {
-    await syncAgentMemory();
-    return;
-  }
-
-  const dir = directory ?? ".";
-
-  const customIgnore = options.ignore
-    ? new Set(options.ignore.split(",").map((s) => s.trim()))
-    : new Set<string>();
-  const ignoreSet = new Set([...DEFAULT_IGNORE, ...customIgnore]);
-
-  console.log(chalk.blue("Scanning"), dir);
-
-  const files = walkDir(dir, ignoreSet);
-
-  if (files.length === 0) {
-    console.log(chalk.yellow("No supported files found."));
-    return;
-  }
-
-  console.log(chalk.gray(`Found ${files.length} files to sync`));
-  console.log();
-
-  let pushed = 0;
-  let errors = 0;
-
-  for (const file of files) {
-    const result = await pushFile(file, options);
-    if (result === "pushed") pushed++;
-    else if (result === "error") errors++;
-  }
-
-  console.log();
-  console.log(
-    chalk.blue(`Synced ${pushed} files`),
-    errors > 0 ? chalk.red(`(${errors} errors)`) : "",
-  );
-
-  if (options.watch) {
-    const resolvedDir = resolve(dir);
-    console.log(
-      chalk.cyan(`\nWatching ${dir} for changes... (Ctrl+C to stop)`),
-    );
-
-    let debounceTimer: NodeJS.Timeout | null = null;
-    const pendingChanges = new Set<string>();
-
-    watch(resolvedDir, { recursive: true }, (_eventType, filename) => {
-      if (!filename) return;
-      const fullPath = join(resolvedDir, filename);
-
-      if (!isSupportedFile(filename) || isIgnored(filename, ignoreSet)) return;
-
-      pendingChanges.add(fullPath);
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(async () => {
-        for (const file of pendingChanges) {
-          if (!existsSync(file)) {
-            console.log(
-              chalk.gray("  ~"),
-              relative(process.cwd(), file),
-              chalk.gray("[deleted, skipped]"),
-            );
-            continue;
-          }
-          await pushFile(file, options);
-        }
-        pendingChanges.clear();
-      }, 500);
-    });
-  }
-}
-
-async function pushFile(
-  file: string,
-  options: SyncOptions,
-): Promise<"pushed" | "skipped" | "error"> {
-  try {
-    const content = readFileSync(file, "utf-8");
-    if (!content.trim()) return "skipped";
-
-    const relPath = relative(process.cwd(), file);
-    const ext = extname(file);
-    const contentType =
-      ext === ".md"
-        ? "markdown"
-        : ext === ".json" || ext === ".yaml" || ext === ".yml"
-          ? "structured"
-          : "code";
-
-    const note = await apiPost<Note>("/v1/notes", {
-      content,
-      title: relPath,
-      category: options.category ?? guessCategory(relPath),
-      source: "sync",
-      source_path: relPath,
-      content_type: contentType,
-    });
-
-    console.log(chalk.green("  +"), relPath, chalk.gray(`[${note.category}]`));
-    return "pushed";
-  } catch (err) {
-    console.log(chalk.red("  x"), file, chalk.gray((err as Error).message));
-    return "error";
-  }
-}
-
-function isSupportedFile(filename: string): boolean {
-  return SUPPORTED_EXTENSIONS.has(extname(filename));
-}
-
-function isIgnored(filename: string, ignoreSet: Set<string>): boolean {
-  const parts = filename.split(/[/\\]/);
-  return parts.some((part) => ignoreSet.has(part) || part.startsWith("."));
-}
-
-function walkDir(dir: string, ignore: Set<string>): string[] {
-  const files: string[] = [];
-
-  function walk(currentDir: string): void {
-    let entries: string[];
-    try {
-      entries = readdirSync(currentDir);
-    } catch {
-      return;
-    }
-
-    for (const entry of entries) {
-      if (ignore.has(entry) || entry.startsWith(".")) continue;
-
-      const fullPath = join(currentDir, entry);
-      let stat;
-      try {
-        stat = statSync(fullPath);
-      } catch {
-        continue;
-      }
-
-      if (stat.isDirectory()) {
-        walk(fullPath);
-      } else if (stat.isFile() && SUPPORTED_EXTENSIONS.has(extname(entry))) {
-        files.push(fullPath);
-      }
-    }
-  }
-
-  walk(dir);
-  return files;
-}
-
-function guessCategory(path: string): string {
-  const lower = path.toLowerCase();
-  if (lower.includes("adr") || lower.includes("decision"))
-    return "decisions/adr";
-  if (lower.includes("deploy") || lower.includes("ci")) return "process/deploy";
-  if (lower.includes("architecture") || lower.includes("design"))
-    return "core/architecture";
-  if (lower.includes("readme") || lower.includes("docs"))
-    return "reference/api";
-  if (lower.includes("test")) return "reference/api";
-  if (lower.includes("config") || lower.includes(".env"))
-    return "reference/config";
-  return "daily/note";
-}
-
-// --- Agent memory sync ---
-
-interface AgentMemoryLocation {
-  label: string;
-  path: string;
-}
-
-function discoverAgentMemoryFiles(): AgentMemoryLocation[] {
-  const home = homedir();
-  const cwd = process.cwd();
-  const locations: AgentMemoryLocation[] = [];
-
-  // Claude Code global memory
-  const claudeMemory = join(home, ".claude", "MEMORY.md");
-  locations.push({ label: "~/.claude/MEMORY.md", path: claudeMemory });
-
-  // Claude Code per-project memories: ~/.claude/projects/*/memory/*.md
-  const claudeProjectsDir = join(home, ".claude", "projects");
-  if (existsSync(claudeProjectsDir)) {
-    try {
-      for (const project of readdirSync(claudeProjectsDir)) {
-        const memoryDir = join(claudeProjectsDir, project, "memory");
-        if (existsSync(memoryDir)) {
-          try {
-            for (const file of readdirSync(memoryDir)) {
-              if (file.endsWith(".md")) {
-                locations.push({
-                  label: `~/.claude/projects/${project}/memory/${file}`,
-                  path: join(memoryDir, file),
-                });
-              }
-            }
-          } catch {
-            // Permission denied or other read error — skip
-          }
-        }
-      }
-    } catch {
-      // Permission denied or other read error — skip
-    }
-  }
-
-  // Cursor rules (project-level)
-  locations.push({ label: "./.cursorrules", path: join(cwd, ".cursorrules") });
-
-  // Cursor scoped rules: .cursor/rules/*.mdc
-  const cursorRulesDir = join(cwd, ".cursor", "rules");
-  if (existsSync(cursorRulesDir)) {
-    try {
-      for (const file of readdirSync(cursorRulesDir)) {
-        if (file.endsWith(".mdc")) {
-          locations.push({
-            label: `./.cursor/rules/${file}`,
-            path: join(cursorRulesDir, file),
-          });
-        }
-      }
-    } catch {
-      // Skip on error
-    }
-  }
-
-  // Codex instructions
-  locations.push({
-    label: "./.codex/instructions.md",
-    path: join(cwd, ".codex", "instructions.md"),
-  });
-
-  // Generic agent config files in current directory
-  locations.push({ label: "./AGENTS.md", path: join(cwd, "AGENTS.md") });
-  locations.push({ label: "./CLAUDE.md", path: join(cwd, "CLAUDE.md") });
-
-  return locations;
-}
-
-function formatFileSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  return `${(bytes / 1024).toFixed(1)} KB`;
-}
-
-async function syncAgentMemory(): Promise<void> {
-  console.log(chalk.blue("Scanning for agent memory files..."));
-  console.log();
-
-  const locations = discoverAgentMemoryFiles();
-  const found: { label: string; path: string; size: number }[] = [];
-  const notFound: string[] = [];
-
-  for (const loc of locations) {
-    if (existsSync(loc.path)) {
-      try {
-        const stat = statSync(loc.path);
-        if (stat.isFile() && stat.size > 0) {
-          found.push({ label: loc.label, path: loc.path, size: stat.size });
-        } else {
-          notFound.push(loc.label);
-        }
-      } catch {
-        notFound.push(loc.label);
-      }
-    } else {
-      notFound.push(loc.label);
-    }
-  }
-
-  if (found.length === 0) {
-    console.log(chalk.yellow("No agent memory files found."));
-    return;
-  }
-
-  console.log("Found:");
-
-  for (const f of found) {
-    console.log(
-      chalk.green("  \u2713"),
-      f.label,
-      chalk.gray(`(${formatFileSize(f.size)})`),
-    );
-  }
-  for (const label of notFound) {
-    console.log(
-      chalk.gray("  \u2717"),
-      chalk.gray(label),
-      chalk.gray("(not found)"),
-    );
-  }
-
-  console.log();
-
-  let synced = 0;
-  let unchanged = 0;
-  let errors = 0;
-
-  for (const f of found) {
-    try {
-      const content = readFileSync(f.path, "utf-8");
-      if (!content.trim()) continue;
-
-      const title = basename(f.path);
-
-      await apiPost<Note>("/v1/notes", {
-        content,
-        title,
-        source: "sync",
-        source_path: f.path,
-        content_type: "markdown",
-        category: "",
-      });
-
-      synced++;
-    } catch (err) {
-      const msg = (err as Error).message;
-      if (
-        msg.includes("unchanged") ||
-        msg.includes("duplicate") ||
-        msg.includes("exists")
-      ) {
-        unchanged++;
-      } else {
-        errors++;
-        console.log(chalk.red("  Error syncing"), f.label, chalk.gray(msg));
-      }
-    }
-  }
-
-  console.log(
-    chalk.blue(`Synced ${found.length} files to Memax`),
-    chalk.gray(
-      `(${synced} new, ${unchanged} unchanged${errors > 0 ? `, ${errors} errors` : ""})`,
-    ),
-  );
-}

package/src/index.ts

@@ -1,192 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { join, dirname } from "node:path";
-import { pushCommand } from "./commands/push.js";
-import { recallCommand } from "./commands/recall.js";
-import { listCommand } from "./commands/list.js";
-import { showCommand } from "./commands/show.js";
-import { deleteCommand } from "./commands/delete.js";
-import { syncCommand, syncAgentMemoryCommand } from "./commands/sync.js";
-import { hookCommand } from "./commands/hook.js";
-import { configGetCommand, configSetCommand } from "./commands/config.js";
-import {
-  loginCommand,
-  logoutCommand,
-  whoamiCommand,
-} from "./commands/login.js";
-import {
-  createKeyCommand,
-  listKeysCommand,
-  revokeKeyCommand,
-} from "./commands/auth.js";
-import { registerMcpCommand } from "./commands/mcp.js";
-import { setupCommand, teardownCommand } from "./commands/setup.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(
-  readFileSync(join(__dirname, "..", "package.json"), "utf-8"),
-);
-
-const program = new Command();
-
-program
-  .name("memax")
-  .description("Universal context & memory hub for AI agents")
-  .version(pkg.version);
-
-// --- Core commands ---
-
-program
-  .command("push")
-  .description("Save knowledge to your Memax workspace")
-  .option("-f, --file <path>", "File to push")
-  .option("-c, --category <category>", "Category (auto-detected if omitted)")
-  .option("-t, --tags <tags>", "Comma-separated tags")
-  .option("--title <title>", "Note title")
-  .option("--ttl <duration>", "Auto-archive after duration (e.g., 7d, 30d)")
-  .option("--stdin", "Read content from stdin")
-  .action(pushCommand);
-
-program
-  .command("recall [query]")
-  .description("Ask your knowledge a question")
-  .option("-c, --category <category>", "Filter by category")
-  .option("-t, --tags <tags>", "Filter by tags")
-  .option("-l, --limit <n>", "Max results", "5")
-  .option("--format <format>", "Output format: text, json", "text")
-  .option("--hook", "Output in agent-injectable format")
-  .option("--max-tokens <number>", "Maximum tokens to output (approximate)")
-  .option("--include-archived", "Include archived notes")
-  .action(recallCommand);
-
-program
-  .command("list")
-  .description("List your knowledge notes")
-  .option("-c, --category <category>", "Filter by category")
-  .option("--state <state>", "Filter by state: active, cooling, archived")
-  .option("-l, --limit <n>", "Max results", "20")
-  .action(listCommand);
-
-program
-  .command("show <id>")
-  .description("Show a specific note")
-  .action(showCommand);
-
-program
-  .command("delete <id>")
-  .description("Delete a note")
-  .option("--confirm", "Skip confirmation")
-  .action(deleteCommand);
-
-// --- Sync ---
-
-const syncCmd = program
-  .command("sync [directory]")
-  .description("Sync a directory or agent memory to your Memax workspace")
-  .option("-w, --watch", "Watch for changes (coming soon)")
-  .option(
-    "-b, --boundary <level>",
-    "Visibility level: private, team, org",
-    "private",
-  )
-  .option(
-    "-c, --category <category>",
-    "Default category (auto-detected if omitted)",
-  )
-  .option("--ignore <patterns>", "Comma-separated directories to ignore")
-  .option(
-    "--agent-memory",
-    "Sync native AI agent memory files (Claude Code, Cursor, Codex)",
-  )
-  .action(syncCommand);
-
-syncCmd
-  .command("agents")
-  .description("Sync native AI agent memory files to Memax")
-  .action(syncAgentMemoryCommand);
-
-// --- Agent integration setup ---
-
-program
-  .command("setup")
-  .description("Set up AI agent integrations (auto-detects installed agents)")
-  .option("--mcp", "Enable MCP server (agent tools)")
-  .option("--hooks", "Enable context injection hooks")
-  .option("--all", "Enable both MCP and hooks")
-  .option("--only <agents>", "Only configure these agents (comma-separated)")
-  .option("--skip <agents>", "Skip these agents (comma-separated)")
-  .action(setupCommand);
-
-program
-  .command("teardown")
-  .description("Remove Memax integrations from agents")
-  .option("--only <agents>", "Only remove from these agents (comma-separated)")
-  .action(teardownCommand);
-
-program
-  .command("hook <action> <agent>")
-  .description("Manage agent hooks (install/uninstall claude-code)")
-  .action(hookCommand);
-
-// --- Auth ---
-
-program
-  .command("login")
-  .description("Log in to Memax via GitHub")
-  .action(loginCommand);
-
-program
-  .command("logout")
-  .description("Clear saved credentials")
-  .action(logoutCommand);
-
-program
-  .command("whoami")
-  .description("Show current user")
-  .action(whoamiCommand);
-
-// --- API Keys ---
-
-const authCmd = program
-  .command("auth")
-  .description("Manage authentication and API keys");
-
-authCmd
-  .command("create-key <name>")
-  .description("Create an API key for CI/CD or non-interactive use")
-  .option("--expires <days>", "Expire after N days (default: never)")
-  .action(createKeyCommand);
-
-authCmd
-  .command("list-keys")
-  .description("List your API keys")
-  .action(listKeysCommand);
-
-authCmd
-  .command("revoke-key <id>")
-  .description("Revoke an API key")
-  .action(revokeKeyCommand);
-
-// --- MCP Server ---
-
-registerMcpCommand(program);
-
-// --- Config ---
-
-const configCmd = program
-  .command("config")
-  .description("Manage Memax configuration");
-
-configCmd
-  .command("get [key]")
-  .description("Get config value (or all values)")
-  .action(configGetCommand);
-
-configCmd
-  .command("set <key> <value>")
-  .description("Set a config value")
-  .action(configSetCommand);
-
-program.parse();

package/src/lib/api.ts

@@ -1,110 +0,0 @@
-import { loadConfig } from "./config.js";
-import {
-  loadCredentials,
-  saveCredentials,
-  isTokenExpired,
-} from "./credentials.js";
-
-interface ApiEnvelope {
-  data?: unknown;
-  error?: { code: string; message: string };
-}
-
-function getApiUrl(): string {
-  return loadConfig().api_url;
-}
-
-async function authHeaders(): Promise<Record<string, string>> {
-  // 1. MEMAX_API_KEY env var takes priority (CI/CD, non-interactive)
-  const envKey = process.env.MEMAX_API_KEY;
-  if (envKey) {
-    return { Authorization: `Bearer ${envKey}` };
-  }
-
-  // 2. Stored credentials with auto-refresh
-  const creds = loadCredentials();
-  if (!creds?.access_token) return {};
-
-  if (isTokenExpired() && creds.refresh_token) {
-    // Attempt to refresh the access token
-    try {
-      const url = `${getApiUrl()}/v1/auth/refresh`;
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ refresh_token: creds.refresh_token }),
-      });
-      const json = (await res.json()) as ApiEnvelope;
-      if (json.data) {
-        const tokens = json.data as {
-          access_token: string;
-          refresh_token: string;
-          expires_in: number;
-        };
-        saveCredentials({
-          access_token: tokens.access_token,
-          refresh_token: tokens.refresh_token,
-          expires_at: Date.now() + tokens.expires_in * 1000,
-        });
-        return { Authorization: `Bearer ${tokens.access_token}` };
-      }
-    } catch {
-      // Refresh failed — fall through to use stale token (server will reject)
-    }
-  }
-
-  return { Authorization: `Bearer ${creds.access_token}` };
-}
-
-export async function apiPost<T>(path: string, body: unknown): Promise<T> {
-  const url = `${getApiUrl()}${path}`;
-  let res: Response;
-  try {
-    res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...(await authHeaders()) },
-      body: JSON.stringify(body),
-    });
-  } catch {
-    throw new Error(`Cannot reach API at ${url} — is the server running?`);
-  }
-  const json = (await res.json()) as ApiEnvelope;
-  if (json.error) {
-    throw new Error(json.error.message);
-  }
-  return json.data as T;
-}
-
-export async function apiGet<T>(path: string): Promise<T> {
-  const url = `${getApiUrl()}${path}`;
-  let res: Response;
-  try {
-    res = await fetch(url, {
-      headers: { ...(await authHeaders()) },
-    });
-  } catch {
-    throw new Error(`Cannot reach API at ${url} — is the server running?`);
-  }
-  const json = (await res.json()) as ApiEnvelope;
-  if (json.error) {
-    throw new Error(json.error.message);
-  }
-  return json.data as T;
-}
-
-export async function apiDelete(path: string): Promise<void> {
-  const url = `${getApiUrl()}${path}`;
-  let res: Response;
-  try {
-    res = await fetch(url, {
-      method: "DELETE",
-      headers: { ...(await authHeaders()) },
-    });
-  } catch {
-    throw new Error(`Cannot reach API at ${url} — is the server running?`);
-  }
-  const json = (await res.json()) as ApiEnvelope;
-  if (json.error) {
-    throw new Error(json.error.message);
-  }
-}