@superpms/memory-cli 0.1.1

package/README.md

@@ -0,0 +1,54 @@
+# @superpms/memory-cli
+
+Memory system CLI — manage global layer, will sync, vendor distribution, and Cloud Brain integration.
+
+## Install
+
+```bash
+npm install -g @superpms/memory-cli
+```
+
+## Quick Start
+
+```bash
+# Initialize global layer
+memory init --global
+
+# Check status
+memory status
+
+# Sync will
+memory will push    # project → global
+memory will pull    # global → project
+
+# Update vendor
+memory update              # global → current project
+memory update --cloud      # Cloud Brain → global → project
+memory update --cloud --all  # → all registered projects
+
+# Cloud Brain
+memory login
+memory vendor publish --version=1.0.0
+memory vendor download
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `init --global` | Initialize global memory layer |
+| `login` | Authenticate with Cloud Brain |
+| `status` | Show current project memory status |
+| `will <push\|pull\|sync\|broadcast>` | Will synchronization |
+| `will <cloud-push\|cloud-pull>` | Cloud will sync |
+| `update [--cloud] [--all]` | Vendor distribution |
+| `vendor <publish\|latest\|changelog\|download>` | Cloud vendor management |
+| `skill <list\|promote\|demote>` | Skill layer management |
+| `cache <status\|clean>` | Cache management |
+| `projects` | List registered projects |
+| `version` | Show version info |
+
+## Requirements
+
+- Node.js >= 18
+- No external dependencies

package/bin/memory.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const COMMANDS = {
+  init: () => import('../commands/init.mjs'),
+  login: () => import('../commands/login.mjs'),
+  update: () => import('../commands/update.mjs'),
+  will: () => import('../commands/will.mjs'),
+  vendor: () => import('../commands/vendor.mjs'),
+  skill: () => import('../commands/skill.mjs'),
+  cache: () => import('../commands/cache.mjs'),
+  status: () => import('../commands/status.mjs'),
+  version: () => import('../commands/version.mjs'),
+};
+
+const command = process.argv[2];
+const args = process.argv.slice(3);
+
+if (!command || command === '--help' || command === '-h') {
+  console.log(`memory — CLI for memory system
+
+Commands:
+  init                     Initialize memory project (downloads vendor + will from Cloud)
+  login                    Login to Cloud Brain
+  login register           Register a new account
+  login status             Check login status
+  login logout             Remove saved credentials
+  update                   Update vendor from Cloud Brain
+  will publish             Publish will to Cloud Brain
+  will pull                Pull will from Cloud Brain
+  will status              Show will status
+  will versions            List cloud will versions
+  will visibility <v>      Set will visibility (private/public/unlisted)
+  will subscribe <id>      Subscribe to a will
+  will unsubscribe <id>    Unsubscribe from a will
+  will subscriptions       List my subscriptions
+  will subscribers         List who subscribes to my will
+  will sub-pull <id>       Pull a subscribed will
+  vendor publish           Publish vendor to Cloud Brain (admin only)
+  vendor latest            Check latest cloud vendor version
+  vendor changelog         Show vendor changelog
+  vendor download          Download specific vendor version
+  skill list               List all skills
+  skill uninstall <name>   Remove skill from project
+  cache status             Show cache size
+  cache clean              Remove old cache entries
+  status                   Current project status
+  version                  Show CLI version
+
+Options:
+  --help, -h               Show this help message
+`);
+  process.exit(0);
+}
+
+if (!COMMANDS[command]) {
+  console.error(`Unknown command: ${command}`);
+  console.error('Run "memory --help" for available commands.');
+  process.exit(1);
+}
+
+try {
+  const mod = await COMMANDS[command]();
+  await mod.default(args);
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+}

package/commands/cache.mjs

@@ -0,0 +1,99 @@
+import { existsSync, readdirSync, statSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { findProjectRoot } from '../lib/project-store.mjs';
+
+const CACHE_DIR = '.memory/.project/cache';
+
+export default async function cache(args) {
+  const subcommand = args[0];
+
+  if (!subcommand || subcommand === '--help') {
+    console.log(`memory cache — Manage project cache
+
+Subcommands:
+  status                   Show cache size and contents
+  clean [--older-than=30d] Remove old cache entries
+`);
+    return;
+  }
+
+  const handlers = { status: handleStatus, clean: handleClean };
+  const handler = handlers[subcommand];
+  if (!handler) {
+    console.error('Unknown cache subcommand: ' + subcommand);
+    process.exit(1);
+  }
+  await handler(args.slice(1));
+}
+
+function getCacheDir() {
+  const root = findProjectRoot();
+  if (!root) { console.error('Not in a memory project.'); process.exit(1); }
+  return join(root, CACHE_DIR);
+}
+
+function dirSize(dir) {
+  let total = 0;
+  let count = 0;
+  if (!existsSync(dir)) return { total, count };
+  const walk = (d) => {
+    for (const entry of readdirSync(d, { withFileTypes: true })) {
+      const full = join(d, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else { total += statSync(full).size; count++; }
+    }
+  };
+  walk(dir);
+  return { total, count };
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return bytes + ' B';
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+  return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+}
+
+async function handleStatus() {
+  const cacheDir = getCacheDir();
+  if (!existsSync(cacheDir)) { console.log('Cache directory does not exist.'); return; }
+
+  const subdirs = readdirSync(cacheDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+  let totalSize = 0;
+  let totalFiles = 0;
+
+  console.log('=== Cache Status ===\n');
+  for (const sub of subdirs) {
+    const { total, count } = dirSize(join(cacheDir, sub.name));
+    totalSize += total;
+    totalFiles += count;
+    console.log('  ' + sub.name + ': ' + count + ' files, ' + formatSize(total));
+  }
+  console.log('\n  Total: ' + totalFiles + ' files, ' + formatSize(totalSize));
+}
+
+async function handleClean(args) {
+  const olderThanFlag = args.find((a) => a.startsWith('--older-than='))?.split('=')[1];
+  const days = olderThanFlag ? parseInt(olderThanFlag) : 30;
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+
+  const cacheDir = getCacheDir();
+  if (!existsSync(cacheDir)) { console.log('Cache directory does not exist.'); return; }
+
+  const sessionsDir = join(cacheDir, 'workflow-sessions');
+  const evidenceDir = join(cacheDir, 'skill-evidence');
+
+  let removed = 0;
+  for (const dir of [sessionsDir, evidenceDir]) {
+    if (!existsSync(dir)) continue;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      const stat = statSync(full);
+      if (stat.mtimeMs < cutoff) {
+        rmSync(full, { recursive: true, force: true });
+        removed++;
+      }
+    }
+  }
+
+  console.log('Cleaned ' + removed + ' entries older than ' + days + ' days.');
+}

package/commands/init.mjs

@@ -0,0 +1,152 @@
+import { existsSync, cpSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join, resolve, basename, dirname } from 'node:path';
+import { isConfigured } from '../lib/api-client.mjs';
+import { findProjectRoot, getProjectWillCurrent, getProjectVendor, readProjectName } from '../lib/project-store.mjs';
+
+export default async function init(args) {
+  await initProject();
+}
+
+async function initProject() {
+  if (!isConfigured()) {
+    console.error('Not logged in. Run "memory login" first.');
+    process.exit(1);
+  }
+
+  const projectRoot = findProjectRoot();
+  if (projectRoot) {
+    console.log('Memory project already exists at: ' + projectRoot);
+    console.log('Use "memory status" to check current state.');
+    return;
+  }
+
+  const root = process.cwd();
+  console.log('Initializing memory project in: ' + root);
+
+  // 1. Download vendor from Cloud Brain
+  console.log('Downloading vendor from Cloud Brain...');
+  const { cloudVendorDownloadLatest } = await import('../lib/api-client.mjs');
+  const { writeVendorFiles } = await import('./vendor.mjs');
+
+  let vendorDir = join(root, 'memory', 'vendor');
+  try {
+    const result = await cloudVendorDownloadLatest();
+    mkdirSync(vendorDir, { recursive: true });
+    writeVendorFiles(vendorDir, result.files, result.version);
+    console.log('  Vendor v' + result.version + ' (' + Object.keys(result.files).length + ' files)');
+  } catch (err) {
+    if (err.status === 404) {
+      console.log('  No vendor releases on Cloud Brain. Creating empty vendor.');
+      mkdirSync(vendorDir, { recursive: true });
+    } else {
+      console.error('Failed to download vendor: ' + err.message);
+      process.exit(1);
+    }
+  }
+
+  // 2. Bootstrap project from templates
+  const templatesDir = join(vendorDir, 'install', 'templates');
+  if (existsSync(templatesDir)) {
+    bootstrapFromTemplates(root, templatesDir);
+  } else {
+    console.log('  No templates in vendor, creating minimal structure.');
+    bootstrapMinimal(root);
+  }
+
+  // 3. Pull will from Cloud Brain
+  console.log('Pulling will from Cloud Brain...');
+  const { cloudWillPull } = await import('../lib/api-client.mjs');
+  const willDir = getProjectWillCurrent(root);
+  try {
+    const result = await cloudWillPull();
+    mkdirSync(willDir, { recursive: true });
+    for (const [name, content] of Object.entries(result.files)) {
+      writeFileSync(join(willDir, name), content, 'utf8');
+    }
+    console.log('  Will v' + result.version + ' (' + Object.keys(result.files).length + ' files)');
+  } catch (err) {
+    console.log('  No will on Cloud Brain yet. Will directory created empty.');
+    mkdirSync(willDir, { recursive: true });
+  }
+
+  console.log('');
+  console.log('Project initialized. Files created:');
+  console.log('  memory/start.md        — agent entry point');
+  console.log('  memory/vendor/         — system specs (read-only)');
+  console.log('  memory/will/current/   — your will');
+  console.log('  .memory/               — project content');
+}
+
+function readTemplate(templatesDir, relativePath) {
+  const filePath = join(templatesDir, relativePath);
+  if (!existsSync(filePath)) return null;
+  const today = new Date().toISOString().slice(0, 10);
+  return readFileSync(filePath, 'utf8').replace(/\{\{today\}\}/g, today);
+}
+
+function writeIfMissing(filePath, content) {
+  if (!content || existsSync(filePath)) return false;
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content, 'utf8');
+  return true;
+}
+
+function bootstrapFromTemplates(root, templatesDir) {
+  const MEMORY = join(root, 'memory');
+  const DOT_MEMORY = join(root, '.memory');
+  const DOT_PROJECT = join(DOT_MEMORY, '.project');
+
+  // Skeleton directories
+  for (const sub of ['config', 'cache', 'global', 'skills']) {
+    mkdirSync(join(DOT_PROJECT, sub), { recursive: true });
+  }
+
+  // memory/start.md, memory/setup.md
+  writeIfMissing(join(MEMORY, 'start.md'), readTemplate(templatesDir, 'start.md'));
+  writeIfMissing(join(MEMORY, 'setup.md'), readTemplate(templatesDir, 'setup.md'));
+
+  // .memory/ template files
+  const dotMemoryMap = {
+    'README.md':                          join(DOT_MEMORY, 'README.md'),
+    '00-索引.md':                          join(DOT_MEMORY, '00-索引.md'),
+    '.gitignore':                          join(DOT_MEMORY, '.gitignore'),
+    'project/README.md':                   join(DOT_PROJECT, 'README.md'),
+    'config/README.md':                    join(DOT_PROJECT, 'config', 'README.md'),
+    'config/runtime.md':                   join(DOT_PROJECT, 'config', 'runtime.md'),
+    'config/install-lock.md':              join(DOT_PROJECT, 'config', 'install-lock.md'),
+    'cache/README.md':                     join(DOT_PROJECT, 'cache', 'README.md'),
+    'global/00-压缩背景.md':               join(DOT_PROJECT, 'global', '00-压缩背景.md'),
+    'global/01-全局记忆.md':               join(DOT_PROJECT, 'global', '01-全局记忆.md'),
+    'global/03-全局开发规范.md':            join(DOT_PROJECT, 'global', '03-全局开发规范.md'),
+    'skills/README.md':                    join(DOT_PROJECT, 'skills', 'README.md'),
+  };
+  for (const [tplPath, destPath] of Object.entries(dotMemoryMap)) {
+    writeIfMissing(destPath, readTemplate(templatesDir, join('dot-memory', tplPath)));
+  }
+
+  // Agent entry files
+  const agentEntryMap = {
+    'CLAUDE.md':     join(root, 'CLAUDE.md'),
+    'AGENTS.md':     join(root, 'AGENTS.md'),
+    'Agent.md':      join(root, 'Agent.md'),
+    '.cursorrules':  join(root, '.cursorrules'),
+  };
+  for (const [tplName, destPath] of Object.entries(agentEntryMap)) {
+    writeIfMissing(destPath, readTemplate(templatesDir, join('agent-entries', tplName)));
+  }
+  writeIfMissing(
+    join(root, '.github', 'copilot-instructions.md'),
+    readTemplate(templatesDir, join('agent-entries', 'copilot-instructions.md'))
+  );
+}
+
+function bootstrapMinimal(root) {
+  const MEMORY = join(root, 'memory');
+  const DOT_MEMORY = join(root, '.memory');
+  const DOT_PROJECT = join(DOT_MEMORY, '.project');
+
+  for (const sub of ['config', 'cache', 'global', 'skills']) {
+    mkdirSync(join(DOT_PROJECT, sub), { recursive: true });
+  }
+  writeIfMissing(join(MEMORY, 'start.md'), '# Start\n\nRead this file first.\n');
+}

package/commands/login.mjs

@@ -0,0 +1,84 @@
+import { readCredentials } from '../lib/credentials.mjs';
+import { createInterface } from 'node:readline';
+import { cloudRegister, cloudLogin, cloudMe, isConfigured } from '../lib/api-client.mjs';
+import { saveCredentials } from '../lib/credentials.mjs';
+
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export default async function login(args) {
+  const subcommand = args[0];
+
+  if (subcommand === 'register') return handleRegister(args.slice(1));
+  if (subcommand === 'status') return handleStatus();
+  if (subcommand === 'logout') return handleLogout();
+
+  await handleLogin(args);
+}
+
+async function handleLogin(args) {
+  const endpoint = args.find((a) => a.startsWith('--endpoint='))?.split('=')[1];
+
+  const username = await prompt('Username: ');
+  const password = await prompt('Password: ');
+
+  try {
+    const result = await cloudLogin(username, password);
+    saveCredentials(result.api_key, result.user_id, result.will_id, endpoint);
+    console.log('Logged in as: ' + result.display_name + ' (' + result.username + ')');
+    console.log('Will ID: ' + result.will_id);
+  } catch (err) {
+    console.error('Login failed: ' + err.message);
+    process.exit(1);
+  }
+}
+
+async function handleRegister(args) {
+  const endpoint = args.find((a) => a.startsWith('--endpoint='))?.split('=')[1];
+
+  const username = await prompt('Username: ');
+  const password = await prompt('Password: ');
+  const displayName = await prompt('Display name (optional): ');
+
+  try {
+    const result = await cloudRegister(username, password, displayName || undefined);
+    saveCredentials(result.api_key, result.user_id, result.will_id, endpoint);
+    console.log('Registered as: ' + result.display_name + ' (' + result.username + ')');
+    console.log('Will ID: ' + result.will_id);
+  } catch (err) {
+    console.error('Registration failed: ' + err.message);
+    process.exit(1);
+  }
+}
+
+async function handleStatus() {
+  if (!isConfigured()) {
+    console.log('Not logged in. Run "memory login" to authenticate.');
+    return;
+  }
+
+  try {
+    const me = await cloudMe();
+    console.log('Logged in as: ' + me.display_name + ' (' + me.username + ')');
+    console.log('Will ID: ' + me.will_id);
+    console.log('Subscribers: ' + me.subscribers);
+    const creds = readCredentials();
+    console.log('Endpoint: ' + creds.api_endpoint);
+  } catch (err) {
+    console.error('Failed to fetch profile: ' + err.message);
+    console.log('Your API key may be invalid. Run "memory login" to re-authenticate.');
+  }
+}
+
+async function handleLogout() {
+  const { writeCredentials } = await import('../lib/credentials.mjs');
+  writeCredentials({ api_endpoint: readCredentials().api_endpoint, api_key: null, user_id: null, will_id: null });
+  console.log('Logged out.');
+}

package/commands/skill.mjs

@@ -0,0 +1,112 @@
+import { existsSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { findProjectRoot } from '../lib/project-store.mjs';
+
+const PROJECT_SKILLS_DIR = '.memory/.project/skills';
+
+export default async function skill(args) {
+  const subcommand = args[0];
+
+  if (!subcommand || subcommand === '--help') {
+    console.log(`memory skill — Manage project skills
+
+Subcommands:
+  list                     List all skills (vendor + project)
+  uninstall <name>         Remove skill from current project
+`);
+    return;
+  }
+
+  const handlers = {
+    list: handleList,
+    uninstall: handleUninstall,
+  };
+  const handler = handlers[subcommand];
+  if (!handler) {
+    console.error('Unknown skill subcommand: ' + subcommand);
+    process.exit(1);
+  }
+  await handler(args.slice(1));
+}
+
+function getProjectSkillsDir() {
+  const root = findProjectRoot();
+  return root ? join(root, PROJECT_SKILLS_DIR) : null;
+}
+
+function listSkillsIn(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name);
+}
+
+function getSkillMeta(dir, name) {
+  const skillDir = join(dir, name);
+  const skillFile = join(skillDir, 'SKILL.md');
+  let description = '';
+  if (existsSync(skillFile)) {
+    const content = readFileSync(skillFile, 'utf8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+      const descMatch = fmMatch[1].match(/description:\s*(.+)/);
+      if (descMatch) description = descMatch[1].trim();
+    }
+  }
+  return { name, path: skillDir, description };
+}
+
+async function handleList() {
+  const vendorRoot = findProjectRoot();
+  const vendorSkillsDir = vendorRoot ? join(vendorRoot, 'memory/vendor/skills') : null;
+  const projectDir = getProjectSkillsDir();
+
+  console.log('=== Skills ===\n');
+
+  if (vendorSkillsDir && existsSync(vendorSkillsDir)) {
+    const vendorSkills = listSkillsIn(vendorSkillsDir);
+    if (vendorSkills.length > 0) {
+      console.log('System (vendor):');
+      for (const s of vendorSkills) {
+        const meta = getSkillMeta(vendorSkillsDir, s);
+        console.log('  ' + s + (meta.description ? ' — ' + meta.description : ''));
+      }
+      console.log('');
+    }
+  }
+
+  if (projectDir && existsSync(projectDir)) {
+    const projectSkills = listSkillsIn(projectDir);
+    if (projectSkills.length > 0) {
+      console.log('Project:');
+      for (const s of projectSkills) {
+        const meta = getSkillMeta(projectDir, s);
+        console.log('  ' + s + (meta.description ? ' — ' + meta.description : ''));
+      }
+      console.log('');
+    }
+  }
+}
+
+async function handleUninstall(args) {
+  const name = args[0];
+  if (!name) {
+    console.error('Usage: memory skill uninstall <skill-name>');
+    process.exit(1);
+  }
+
+  const projectDir = getProjectSkillsDir();
+  if (!projectDir) {
+    console.error('Not in a memory project.');
+    process.exit(1);
+  }
+
+  const targetDir = join(projectDir, name);
+  if (!existsSync(targetDir)) {
+    console.error('Project skill not found: ' + name);
+    process.exit(1);
+  }
+
+  rmSync(targetDir, { recursive: true, force: true });
+  console.log('Removed skill "' + name + '" from project.');
+}

package/commands/status.mjs

@@ -0,0 +1,28 @@
+import { existsSync } from 'node:fs';
+import { isConfigured } from '../lib/api-client.mjs';
+import { readCredentials } from '../lib/credentials.mjs';
+import { findProjectRoot, getProjectWillCurrent, getProjectVendor } from '../lib/project-store.mjs';
+
+export default async function status() {
+  console.log('=== Memory Status ===\n');
+
+  // Credentials
+  const creds = readCredentials();
+  console.log('Cloud Brain: ' + (isConfigured() ? creds.api_endpoint : 'not configured'));
+  if (isConfigured()) {
+    console.log('  User: ' + (creds.user_id || 'unknown'));
+  }
+
+  console.log('');
+
+  // Project
+  const projectRoot = findProjectRoot();
+  if (projectRoot) {
+    console.log('Project: ' + projectRoot);
+    console.log('  Vendor: ' + (existsSync(getProjectVendor(projectRoot)) ? 'exists' : 'missing'));
+    console.log('  Will:   ' + (existsSync(getProjectWillCurrent(projectRoot)) ? 'exists' : 'missing'));
+  } else {
+    console.log('Project: not in a memory project');
+    console.log('  Run "memory init" to create one.');
+  }
+}

package/commands/update.mjs

@@ -0,0 +1,32 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { isConfigured } from '../lib/api-client.mjs';
+import { findProjectRoot, getProjectVendor } from '../lib/project-store.mjs';
+
+export default async function update(args) {
+  if (!isConfigured()) {
+    console.error('Not logged in. Run "memory login" first.');
+    process.exit(1);
+  }
+
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.error('Not in a memory project. Run "memory init" first.');
+    process.exit(1);
+  }
+
+  const { cloudVendorDownloadLatest } = await import('../lib/api-client.mjs');
+  const { writeVendorFiles } = await import('./vendor.mjs');
+
+  const vendorDir = getProjectVendor(projectRoot);
+
+  try {
+    const result = await cloudVendorDownloadLatest();
+    writeVendorFiles(vendorDir, result.files, result.version);
+    console.log('Vendor updated to v' + result.version + ' (' + Object.keys(result.files).length + ' files).');
+  } catch (err) {
+    if (err.status === 404) { console.log('No vendor releases on Cloud Brain.'); return; }
+    console.error('Download failed: ' + err.message);
+    process.exit(1);
+  }
+}