@superpms/memory-cli 0.1.1

package/commands/vendor.mjs

@@ -0,0 +1,171 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import {
+  isConfigured, cloudVendorLatest, cloudVendorChangelog,
+  cloudVendorPublish, cloudVendorDownload, cloudVendorDownloadLatest,
+} from '../lib/api-client.mjs';
+import { findProjectRoot, getProjectVendor } from '../lib/project-store.mjs';
+
+export default async function vendor(args) {
+  const subcommand = args[0];
+
+  if (!subcommand || subcommand === '--help') {
+    console.log(`memory vendor — Manage vendor distribution
+
+Subcommands:
+  publish [--version=X.Y.Z]   Publish current project vendor to Cloud Brain (admin only)
+  latest                       Check latest cloud vendor version
+  changelog                    Show vendor changelog
+  download [--version=X.Y.Z]  Download specific vendor version to project
+`);
+    return;
+  }
+
+  const handlers = {
+    publish: handlePublish,
+    latest: handleLatest,
+    changelog: handleChangelog,
+    download: handleDownload,
+  };
+  const handler = handlers[subcommand];
+  if (!handler) {
+    console.error('Unknown vendor subcommand: ' + subcommand);
+    process.exit(1);
+  }
+  await handler(args.slice(1));
+}
+
+function collectFiles(dir, base) {
+  const files = {};
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relPath = relative(base, fullPath).replace(/\\/g, '/');
+    if (entry.isDirectory()) {
+      if (entry.name === 'node_modules' || entry.name === '.git') continue;
+      Object.assign(files, collectFiles(fullPath, base));
+    } else {
+      files[relPath] = readFileSync(fullPath, 'utf8');
+    }
+  }
+  return files;
+}
+
+function requireCloud() {
+  if (!isConfigured()) {
+    console.error('Not logged in. Run "memory login" first.');
+    process.exit(1);
+  }
+}
+
+async function handlePublish(args) {
+  requireCloud();
+
+  const versionFlag = args.find((a) => a.startsWith('--version='))?.split('=')[1];
+
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.error('Not in a memory project. Run this command from the memory system root directory.');
+    process.exit(1);
+  }
+
+  const sourceDir = getProjectVendor(projectRoot);
+  if (!existsSync(sourceDir)) {
+    console.error('No memory/vendor/ in current project.');
+    process.exit(1);
+  }
+
+  const versionFile = join(sourceDir, 'version.json');
+  let currentVersion = 'unknown';
+  if (existsSync(versionFile)) {
+    try { currentVersion = JSON.parse(readFileSync(versionFile, 'utf8')).version || 'unknown'; } catch {}
+  }
+
+  const version = versionFlag || currentVersion;
+  if (version === 'unknown') {
+    console.error('Cannot determine version. Use --version=X.Y.Z or ensure vendor/version.json has a version field.');
+    process.exit(1);
+  }
+
+  console.log('Publishing vendor from: ' + sourceDir);
+  const files = collectFiles(sourceDir, sourceDir);
+  console.log('  Files: ' + Object.keys(files).length);
+
+  try {
+    const result = await cloudVendorPublish(version, files);
+    console.log('Published vendor v' + result.version + ' to Cloud Brain.');
+    console.log('  Hash: ' + result.content_hash);
+    console.log('  Files: ' + result.file_count);
+  } catch (err) {
+    console.error('Publish failed: ' + err.message);
+    process.exit(1);
+  }
+}
+
+async function handleLatest() {
+  requireCloud();
+  try {
+    const result = await cloudVendorLatest();
+    console.log('Latest vendor on Cloud Brain:');
+    console.log('  Version: ' + result.version);
+    console.log('  Channel: ' + result.channel);
+    console.log('  Hash:    ' + result.content_hash);
+    console.log('  Date:    ' + result.created_at);
+  } catch (err) {
+    if (err.status === 404) console.log('No vendor releases on Cloud Brain yet.');
+    else console.error('Failed: ' + err.message);
+  }
+}
+
+async function handleChangelog() {
+  requireCloud();
+  try {
+    const result = await cloudVendorChangelog();
+    if (result.releases.length === 0) { console.log('No vendor releases.'); return; }
+    console.log('Vendor changelog:');
+    for (const r of result.releases) {
+      console.log('  v' + r.version + ' (' + r.channel + ') — ' + r.created_at);
+      if (r.changelog) console.log('    ' + r.changelog);
+    }
+  } catch (err) {
+    console.error('Failed: ' + err.message);
+  }
+}
+
+async function handleDownload(args) {
+  requireCloud();
+  const versionFlag = args.find?.((a) => a.startsWith('--version='))?.split('=')[1];
+
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.error('Not in a memory project. Run "memory init" first.');
+    process.exit(1);
+  }
+
+  const vendorDir = getProjectVendor(projectRoot);
+
+  try {
+    const result = versionFlag
+      ? await cloudVendorDownload(versionFlag)
+      : await cloudVendorDownloadLatest();
+
+    writeVendorFiles(vendorDir, result.files, result.version);
+
+    console.log('Downloaded vendor v' + result.version + ' from Cloud Brain.');
+    console.log('  Files: ' + Object.keys(result.files).length);
+  } catch (err) {
+    if (err.status === 404) console.log('Version not found on Cloud Brain.');
+    else console.error('Download failed: ' + err.message);
+  }
+}
+
+// Shared helper — also used by update and init
+export function writeVendorFiles(dir, files, version) {
+  for (const [relPath, content] of Object.entries(files)) {
+    const fullPath = join(dir, relPath);
+    mkdirSync(join(fullPath, '..'), { recursive: true });
+    writeFileSync(fullPath, content, 'utf8');
+  }
+  const versionData = { version, source: 'cloud-brain', updated: new Date().toISOString() };
+  writeFileSync(join(dir, 'version.json'), JSON.stringify(versionData, null, 2) + '\n', 'utf8');
+}

package/commands/version.mjs

@@ -0,0 +1,29 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findProjectRoot, getProjectVendor } from '../lib/project-store.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default async function version() {
+  const pkgPath = join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  console.log('CLI version: ' + pkg.version);
+
+  const projectRoot = findProjectRoot();
+  if (projectRoot) {
+    const versionFile = join(getProjectVendor(projectRoot), 'version.json');
+    if (existsSync(versionFile)) {
+      try {
+        const v = JSON.parse(readFileSync(versionFile, 'utf8'));
+        console.log('Vendor: ' + (v.version || 'unknown') + (v.updated ? ' (updated: ' + v.updated + ')' : ''));
+      } catch {
+        console.log('Vendor: version.json unreadable');
+      }
+    } else {
+      console.log('Vendor: not installed');
+    }
+  } else {
+    console.log('Vendor: not in a memory project');
+  }
+}

package/commands/will.mjs

@@ -0,0 +1,270 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { findProjectRoot, getProjectWillCurrent } from '../lib/project-store.mjs';
+import {
+  isConfigured, cloudWillPush, cloudWillPull, cloudWillVersions, cloudWillSetVisibility,
+  cloudSubscribe, cloudUnsubscribe, cloudListSubscriptions, cloudListSubscribers, cloudPullSubscription,
+} from '../lib/api-client.mjs';
+
+const WILL_FILES = ['00-压缩意志.md', '01-身份与目标.md', '02-开发偏好.md', '03-思维决策.md', '04-沟通协作.md'];
+
+export default async function will(args) {
+  const subcommand = args[0];
+
+  if (!subcommand || subcommand === '--help') {
+    console.log(`memory will — Manage will
+
+Subcommands:
+  publish           Publish project will to Cloud Brain
+  pull              Pull will from Cloud Brain to project
+  status            Show will status
+  versions          List cloud will versions
+  visibility <v>    Set will visibility (private/public/unlisted)
+  subscribe <id> [--dimensions 02,03]   Subscribe to a will
+  unsubscribe <id>  Unsubscribe from a will
+  subscriptions     List my subscriptions
+  subscribers       List who subscribes to my will
+  sub-pull <id>     Pull a subscribed will to project
+`);
+    return;
+  }
+
+  const handlers = {
+    publish: handlePublish, pull: handlePull, status: handleStatus,
+    versions: handleVersions, visibility: handleVisibility,
+    subscribe: handleSubscribe, unsubscribe: handleUnsubscribe,
+    subscriptions: handleSubscriptions, subscribers: handleSubscribers,
+    'sub-pull': handleSubPull,
+    // backward compat
+    'cloud-push': handlePublish, 'cloud-pull': handlePull,
+  };
+  const handler = handlers[subcommand];
+  if (!handler) {
+    console.error('Unknown will subcommand: ' + subcommand);
+    process.exit(1);
+  }
+  await handler(args.slice(1));
+}
+
+// --- Core ---
+
+function requireProject() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.error('Not in a memory project. Run "memory init" first.');
+    process.exit(1);
+  }
+  return projectRoot;
+}
+
+function requireCloud() {
+  if (!isConfigured()) {
+    console.error('Not logged in. Run "memory login" first.');
+    process.exit(1);
+  }
+}
+
+function readWillFiles(dir) {
+  const files = {};
+  for (const f of WILL_FILES) {
+    const p = join(dir, f);
+    if (existsSync(p)) files[f] = readFileSync(p, 'utf8');
+  }
+  return files;
+}
+
+// --- Handlers ---
+
+async function handlePublish() {
+  const projectRoot = requireProject();
+  requireCloud();
+
+  const willDir = getProjectWillCurrent(projectRoot);
+  if (!existsSync(willDir)) {
+    console.error('No will directory. Run "memory will pull" first.');
+    process.exit(1);
+  }
+
+  const files = readWillFiles(willDir);
+  if (Object.keys(files).length === 0) {
+    console.error('No will files found in: ' + willDir);
+    process.exit(1);
+  }
+
+  try {
+    const result = await cloudWillPush(files);
+    console.log('Will published to Cloud Brain.');
+    console.log('  Version: ' + result.version);
+    console.log('  Files: ' + Object.keys(files).length);
+  } catch (err) {
+    console.error('Publish failed: ' + err.message);
+    process.exit(1);
+  }
+}
+
+async function handlePull() {
+  const projectRoot = requireProject();
+  requireCloud();
+
+  const willDir = getProjectWillCurrent(projectRoot);
+
+  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 pulled from Cloud Brain.');
+    console.log('  Version: ' + result.version);
+    console.log('  Files: ' + Object.keys(result.files).length);
+  } catch (err) {
+    console.error('Pull failed: ' + err.message);
+    process.exit(1);
+  }
+}
+
+async function handleStatus() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log('Not in a memory project.');
+    return;
+  }
+
+  const willDir = getProjectWillCurrent(projectRoot);
+  const willExists = existsSync(willDir);
+  const fileCount = willExists
+    ? WILL_FILES.filter(f => existsSync(join(willDir, f))).length
+    : 0;
+
+  console.log('Will status:');
+  console.log('  Directory: ' + (willExists ? 'exists' : 'missing'));
+  console.log('  Files: ' + fileCount + '/' + WILL_FILES.length);
+  console.log('  Cloud: ' + (isConfigured() ? 'connected' : 'not configured'));
+}
+
+async function handleVersions() {
+  requireCloud();
+  try {
+    const result = await cloudWillVersions();
+    if (result.versions.length === 0) { console.log('No will versions.'); return; }
+    console.log('Will versions:');
+    for (const v of result.versions) {
+      console.log('  v' + v.version + ' — ' + v.created_at);
+    }
+  } catch (err) {
+    console.error('Failed: ' + err.message);
+  }
+}
+
+async function handleVisibility(args) {
+  requireCloud();
+  const visibility = args[0];
+  if (!visibility || !['private', 'public', 'unlisted'].includes(visibility)) {
+    console.error('Usage: memory will visibility <private|public|unlisted>');
+    process.exit(1);
+  }
+  try {
+    await cloudWillSetVisibility(visibility);
+    console.log('Will visibility set to: ' + visibility);
+  } catch (err) {
+    console.error('Failed: ' + err.message);
+  }
+}
+
+async function handleSubscribe(args) {
+  requireCloud();
+  const willId = args[0];
+  if (!willId) {
+    console.error('Usage: memory will subscribe <will_id> [--dimensions 02,03]');
+    process.exit(1);
+  }
+  const dimFlag = args.find(a => a.startsWith('--dimensions='))?.split('=')[1]
+    || (args.indexOf('--dimensions') >= 0 ? args[args.indexOf('--dimensions') + 1] : null);
+  const dimensions = dimFlag ? dimFlag.split(',').map(d => d.trim()) : undefined;
+
+  try {
+    const result = await cloudSubscribe(willId, dimensions);
+    console.log('Subscribed to: ' + result.will_id);
+    console.log('  Owner: ' + result.owner.display_name);
+    if (result.dimensions) console.log('  Dimensions: ' + result.dimensions.join(', '));
+  } catch (err) {
+    console.error('Subscribe failed: ' + err.message);
+  }
+}
+
+async function handleUnsubscribe(args) {
+  requireCloud();
+  const willId = args[0];
+  if (!willId) {
+    console.error('Usage: memory will unsubscribe <will_id>');
+    process.exit(1);
+  }
+  try {
+    await cloudUnsubscribe(willId);
+    console.log('Unsubscribed from: ' + willId);
+  } catch (err) {
+    console.error('Unsubscribe failed: ' + err.message);
+  }
+}
+
+async function handleSubscriptions() {
+  requireCloud();
+  try {
+    const result = await cloudListSubscriptions();
+    if (result.subscriptions.length === 0) { console.log('No subscriptions.'); return; }
+    console.log('Subscriptions:');
+    for (const s of result.subscriptions) {
+      console.log('  ' + s.will_id + ' — ' + s.owner.display_name + (s.dimensions ? ' [' + s.dimensions.join(',') + ']' : ''));
+    }
+  } catch (err) {
+    console.error('Failed: ' + err.message);
+  }
+}
+
+async function handleSubscribers() {
+  requireCloud();
+  try {
+    const result = await cloudListSubscribers();
+    if (result.subscribers.length === 0) { console.log('No subscribers.'); return; }
+    console.log('Subscribers:');
+    for (const s of result.subscribers) {
+      console.log('  ' + s.username + ' (' + s.display_name + ')' + (s.dimensions ? ' [' + s.dimensions.join(',') + ']' : ''));
+    }
+  } catch (err) {
+    console.error('Failed: ' + err.message);
+  }
+}
+
+async function handleSubPull(args) {
+  requireCloud();
+  const projectRoot = requireProject();
+  const willId = args[0];
+  if (!willId) {
+    console.error('Usage: memory will sub-pull <will_id>');
+    process.exit(1);
+  }
+
+  try {
+    const result = await cloudPullSubscription(willId);
+    // Save to project .memory/.project/subscriptions/<will_id>/
+    const subDir = join(projectRoot, '.memory', '.project', 'subscriptions', result.will_id);
+    mkdirSync(subDir, { recursive: true });
+    for (const [name, content] of Object.entries(result.files)) {
+      writeFileSync(join(subDir, name), content, 'utf8');
+    }
+    writeFileSync(join(subDir, 'manifest.json'), JSON.stringify({
+      will_id: result.will_id,
+      owner: result.owner,
+      version: result.version,
+      dimensions: result.dimensions,
+      synced_at: new Date().toISOString(),
+    }, null, 2) + '\n', 'utf8');
+
+    console.log('Pulled subscription: ' + result.will_id);
+    console.log('  Owner: ' + result.owner.display_name + ' (' + result.owner.username + ')');
+    console.log('  Version: ' + result.version);
+    console.log('  Saved to: ' + subDir);
+  } catch (err) {
+    console.error('Pull failed: ' + err.message);
+  }
+}

package/lib/api-client.mjs

@@ -0,0 +1,155 @@
+/**
+ * Cloud Brain API client.
+ */
+
+import { readCredentials } from './credentials.mjs';
+import { request } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+
+function getEndpoint() {
+  return readCredentials().api_endpoint || 'http://localhost:3900';
+}
+
+function getApiKey() {
+  return readCredentials().api_key;
+}
+
+function isConfigured() {
+  const creds = readCredentials();
+  return !!(creds.api_key && creds.api_endpoint);
+}
+
+function httpFetch(method, path, body = null) {
+  return new Promise((resolve, reject) => {
+    const endpoint = getEndpoint();
+    const url = new URL(path, endpoint);
+    const isHttps = url.protocol === 'https:';
+    const reqFn = isHttps ? httpsRequest : request;
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    };
+
+    const apiKey = getApiKey();
+    if (apiKey) options.headers['Authorization'] = 'Bearer ' + apiKey;
+
+    const req = reqFn(options, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        const raw = Buffer.concat(chunks).toString('utf8');
+        try {
+          const data = JSON.parse(raw);
+          if (res.statusCode >= 400) {
+            const err = new Error(data.error || 'API error');
+            err.status = res.statusCode;
+            err.data = data;
+            reject(err);
+          } else {
+            resolve(data);
+          }
+        } catch (e) {
+          reject(new Error('Invalid JSON response: ' + raw.slice(0, 200)));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+// --- Auth ---
+
+export async function cloudRegister(username, password, displayName) {
+  return httpFetch('POST', '/auth/register', { username, password, display_name: displayName });
+}
+
+export async function cloudLogin(username, password) {
+  return httpFetch('POST', '/auth/login', { username, password });
+}
+
+export async function cloudMe() {
+  return httpFetch('GET', '/auth/me');
+}
+
+// --- Will ---
+
+export async function cloudWillPush(files) {
+  return httpFetch('PUT', '/will/me', { files });
+}
+
+export async function cloudWillPull() {
+  return httpFetch('GET', '/will/me/pull');
+}
+
+export async function cloudWillVersions() {
+  return httpFetch('GET', '/will/me/versions');
+}
+
+export async function cloudWillSetVisibility(visibility) {
+  return httpFetch('PUT', '/will/me/visibility', { visibility });
+}
+
+export async function cloudGetWill(willId) {
+  return httpFetch('GET', '/will/' + willId);
+}
+
+export async function cloudGetWillDimension(willId, dimension) {
+  return httpFetch('GET', '/will/' + willId + '/dimensions/' + dimension);
+}
+
+// --- Subscriptions ---
+
+export async function cloudSubscribe(willId, dimensions) {
+  return httpFetch('POST', '/will/subscribe', { will_id: willId, dimensions });
+}
+
+export async function cloudUnsubscribe(willId) {
+  return httpFetch('DELETE', '/will/unsubscribe/' + willId);
+}
+
+export async function cloudListSubscriptions() {
+  return httpFetch('GET', '/will/subscriptions');
+}
+
+export async function cloudListSubscribers() {
+  return httpFetch('GET', '/will/subscribers');
+}
+
+export async function cloudPullSubscription(willId) {
+  return httpFetch('GET', '/will/subscribe/' + willId + '/pull');
+}
+
+// --- Vendor ---
+
+export async function cloudVendorLatest() {
+  return httpFetch('GET', '/vendor/latest');
+}
+
+export async function cloudVendorChangelog() {
+  return httpFetch('GET', '/vendor/changelog');
+}
+
+export async function cloudVendorPublish(version, files, channel = 'stable') {
+  return httpFetch('POST', '/vendor/publish', { version, files, channel });
+}
+
+export async function cloudVendorDownload(version) {
+  return httpFetch('GET', '/vendor/download/' + version);
+}
+
+export async function cloudVendorDownloadLatest() {
+  return httpFetch('GET', '/vendor/download/latest');
+}
+
+// --- Helpers ---
+
+export { isConfigured, getEndpoint, getApiKey };

package/lib/credentials.mjs

@@ -0,0 +1,48 @@
+/**
+ * Minimal credentials store — ~/.memory-cli/credentials.json
+ * Only stores API endpoint, key, user_id, will_id.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CREDENTIALS_DIR = process.env.MEMORY_CREDENTIALS_DIR || join(homedir(), '.memory-cli');
+const CREDENTIALS_PATH = join(CREDENTIALS_DIR, 'credentials.json');
+
+const DEFAULT_CREDENTIALS = {
+  api_endpoint: null,
+  api_key: null,
+  user_id: null,
+  will_id: null,
+};
+
+export function readCredentials() {
+  if (!existsSync(CREDENTIALS_PATH)) return { ...DEFAULT_CREDENTIALS };
+  try {
+    return { ...DEFAULT_CREDENTIALS, ...JSON.parse(readFileSync(CREDENTIALS_PATH, 'utf8')) };
+  } catch {
+    return { ...DEFAULT_CREDENTIALS };
+  }
+}
+
+export function writeCredentials(data) {
+  mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+export function isConfigured() {
+  const creds = readCredentials();
+  return !!(creds.api_key && creds.api_endpoint);
+}
+
+export function saveCredentials(apiKey, userId, willId, endpoint) {
+  const creds = readCredentials();
+  creds.api_key = apiKey;
+  creds.user_id = userId;
+  creds.will_id = willId;
+  if (endpoint) creds.api_endpoint = endpoint;
+  writeCredentials(creds);
+}
+
+export { CREDENTIALS_DIR, CREDENTIALS_PATH };