memax-cli 0.1.0-alpha.11 → 0.1.0-alpha.13

package/src/commands/show.ts

@@ -1,35 +0,0 @@
-import chalk from "chalk";
-import { apiGet } from "../lib/api.js";
-import type { Note } from "@memaxlabs/shared";
-
-export async function showCommand(id: string): Promise<void> {
-  if (!id) {
-    console.error(chalk.red("Provide a note ID: memax show <id>"));
-    process.exit(1);
-  }
-
-  try {
-    const note = await apiGet<Note>(`/v1/notes/${id}`);
-
-    console.log(chalk.bold(note.title));
-    console.log(
-      chalk.gray(
-        `${note.category} · ${note.source} · v${note.version} · ${note.state}`,
-      ),
-    );
-    if (note.tags?.length) {
-      console.log(chalk.gray(`tags: ${note.tags.join(", ")}`));
-    }
-    console.log(chalk.gray(`id: ${note.id}`));
-    console.log();
-    // API returns content inline; the shared Note type doesn't include it
-    // because production stores content in R2. Cast to access it.
-    const content = (note as Note & { content?: string }).content;
-    if (content) {
-      console.log(content);
-    }
-  } catch (err) {
-    console.error(chalk.red(`Show failed: ${(err as Error).message}`));
-    process.exit(1);
-  }
-}

package/src/commands/sync.ts

@@ -1,506 +0,0 @@
-import chalk from "chalk";
-import {
-  readFileSync,
-  readdirSync,
-  statSync,
-  watch,
-  existsSync,
-} from "node:fs";
-import { createInterface } from "node:readline";
-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;
-  yes?: 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`));
-
-  // Confirm if many files (>10) unless -y is passed
-  if (files.length > 10 && !options.yes) {
-    console.log(
-      chalk.yellow(
-        `\n  This will push ${files.length} files. Continue? (y/N) `,
-      ),
-    );
-    const confirmed = await confirmSync();
-    if (!confirmed) {
-      console.log(chalk.gray("  Cancelled.\n"));
-      return;
-    }
-  }
-
-  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"),
-  });
-  locations.push({
-    label: "~/.codex/AGENTS.md",
-    path: join(home, ".codex", "AGENTS.md"),
-  });
-
-  // Gemini CLI
-  locations.push({
-    label: "~/.gemini/GEMINI.md",
-    path: join(home, ".gemini", "GEMINI.md"),
-  });
-  locations.push({ label: "./GEMINI.md", path: join(cwd, "GEMINI.md") });
-
-  // GitHub Copilot
-  locations.push({
-    label: "./.github/copilot-instructions.md",
-    path: join(cwd, ".github", "copilot-instructions.md"),
-  });
-
-  // Windsurf
-  locations.push({
-    label: "./.windsurfrules",
-    path: join(cwd, ".windsurfrules"),
-  });
-  const windsurfRulesDir = join(cwd, ".windsurf", "rules");
-  if (existsSync(windsurfRulesDir)) {
-    try {
-      for (const file of readdirSync(windsurfRulesDir)) {
-        if (file.endsWith(".md")) {
-          locations.push({
-            label: `./.windsurf/rules/${file}`,
-            path: join(windsurfRulesDir, file),
-          });
-        }
-      }
-    } catch {
-      // Skip on error
-    }
-  }
-
-  // OpenClaw memory
-  const openclawMemoryDir = join(home, ".openclaw", "memory");
-  if (existsSync(openclawMemoryDir)) {
-    try {
-      for (const file of readdirSync(openclawMemoryDir)) {
-        if (file.endsWith(".md") || file.endsWith(".json")) {
-          locations.push({
-            label: `~/.openclaw/memory/${file}`,
-            path: join(openclawMemoryDir, file),
-          });
-        }
-      }
-    } catch {
-      // Skip on error
-    }
-  }
-
-  // OpenCode (anomalyco) context
-  const opencodePath = join(cwd, ".opencode");
-  if (existsSync(opencodePath)) {
-    // Check for any markdown context files in .opencode/
-    try {
-      for (const file of readdirSync(opencodePath)) {
-        if (file.endsWith(".md")) {
-          locations.push({
-            label: `./.opencode/${file}`,
-            path: join(opencodePath, file),
-          });
-        }
-      }
-    } catch {
-      // Skip on error
-    }
-  }
-
-  // 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` : ""})`,
-    ),
-  );
-}
-
-function confirmSync(): Promise<boolean> {
-  return new Promise((resolve) => {
-    const rl = createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-    rl.question("  ", (answer) => {
-      rl.close();
-      resolve(answer.trim().toLowerCase() === "y");
-    });
-  });
-}