clawkeep 0.1.0

package/src/commands/backup.js

@@ -0,0 +1,276 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const ClawGit = require('../core/git');
+const BackupManager = require('../core/backup');
+
+module.exports = async function backup(subcommand, args, opts) {
+  // Restore doesn't need an initialized repo — it creates a new one
+  if (subcommand === 'restore') {
+    return doRestore(args, opts);
+  }
+
+  const dir = path.resolve(opts.dir || '.');
+
+  const claw = new ClawGit(dir);
+  if (!(await claw.isInitialized())) {
+    console.error(chalk.red('Not initialized. Run `clawkeep init` first.'));
+    process.exit(1);
+  }
+
+  const bm = new BackupManager(claw);
+
+  if (!subcommand || subcommand === 'status') {
+    return showStatus(bm);
+  } else if (subcommand === 'set-target') {
+    return setTarget(bm, args, opts);
+  } else if (subcommand === 'set-password') {
+    return doSetPassword(bm, opts);
+  } else if (subcommand === 'sync') {
+    return doSync(bm, opts);
+  } else if (subcommand === 'pull') {
+    return doPull(bm);
+  } else if (subcommand === 'test') {
+    return doTest(bm);
+  } else if (subcommand === 'compact') {
+    return doCompact(bm, opts);
+  } else {
+    // Treat subcommand as target type shorthand: `clawkeep backup local /path`
+    return setTarget(bm, subcommand, opts);
+  }
+};
+
+function getPassword(opts) {
+  return opts.password || process.env.CLAWKEEP_PASSWORD || null;
+}
+
+async function showStatus(bm) {
+  const cfg = bm.getConfig();
+  console.log('');
+  console.log(chalk.bold('  Backup Status'));
+  console.log('');
+
+  if (!cfg.target) {
+    console.log(`  ${chalk.yellow('\u25cf')} No backup target configured`);
+    console.log('');
+    console.log(chalk.dim('  Set one up:'));
+    console.log(chalk.dim('  $ clawkeep backup local /path/to/backup'));
+    console.log(chalk.dim('  $ clawkeep backup git <remote-url>'));
+  } else {
+    const icon = { local: '\ud83d\udcc1', cloud: '\ud83d\udc3e', s3: '\ud83e\udea3', git: '\ud83d\udd17' }[cfg.target] || '?';
+    console.log(`  Target:      ${icon} ${chalk.white(cfg.target)} \u2014 ${cfg.targetLabel}`);
+    console.log(`  Auto-sync:   ${cfg.autoSync ? chalk.green('on') : chalk.dim('off')}`);
+    if (cfg.lastSync) {
+      console.log(`  Last sync:   ${chalk.dim(cfg.lastSync)}`);
+    } else {
+      console.log(`  Last sync:   ${chalk.dim('never')}`);
+    }
+
+    // Encryption status
+    if (cfg.target === 'local') {
+      console.log(`  Encrypted:   ${cfg.passwordSet ? chalk.green('\u2713 yes') : chalk.yellow('\u26a0 password not set')}`);
+      if (cfg.chunkCount > 0) {
+        console.log(`  Chunks:      ${cfg.chunkCount}`);
+      }
+      if (cfg.workspaceId) {
+        console.log(`  Workspace:   ${chalk.dim(cfg.workspaceId)}`);
+      }
+    }
+  }
+  console.log('');
+}
+
+async function setTarget(bm, typeOrArgs, opts) {
+  let type, options = {};
+
+  if (typeof typeOrArgs === 'string') {
+    type = typeOrArgs;
+  } else {
+    type = typeOrArgs;
+  }
+
+  // Handle: `clawkeep backup local /path`
+  if (type === 'local') {
+    const targetPath = opts.path || opts.args?.[0];
+    if (!targetPath) {
+      console.error(chalk.red('  Usage: clawkeep backup local <path>'));
+      process.exit(1);
+    }
+    options.path = targetPath;
+  } else if (type === 'git') {
+    const url = opts.path || opts.args?.[0];
+    if (!url) {
+      console.error(chalk.red('  Usage: clawkeep backup git <remote-url>'));
+      process.exit(1);
+    }
+    options.url = url;
+  }
+
+  const spinner = ora('Setting up backup target...').start();
+  try {
+    const cfg = await bm.setTarget(type, options);
+    spinner.succeed('Backup target configured');
+    console.log(`  Target: ${cfg.target} \u2014 ${cfg.targetLabel}`);
+    console.log('');
+
+    // Auto-test
+    const test = await bm.test();
+    if (test.ok) {
+      console.log(`  ${chalk.green('\u2713')} ${test.message}${test.latencyMs ? ` (${test.latencyMs}ms)` : ''}`);
+    } else {
+      console.log(`  ${chalk.yellow('\u26a0')} ${test.message}`);
+    }
+
+    // Remind about password for local targets
+    if (type === 'local' && !bm.hasPassword()) {
+      console.log('');
+      console.log(chalk.yellow('  \u26a0 Set a password before syncing:'));
+      console.log(chalk.dim('  $ clawkeep backup set-password'));
+      console.log(chalk.dim('  or: CLAWKEEP_PASSWORD=xxx clawkeep backup set-password'));
+    }
+    console.log('');
+  } catch (err) {
+    spinner.fail('Failed to set target');
+    console.error(chalk.red('  ' + err.message));
+    process.exit(1);
+  }
+}
+
+async function doSetPassword(bm, opts) {
+  const password = getPassword(opts);
+  if (!password) {
+    console.error(chalk.red('  Password required.'));
+    console.error(chalk.dim('  Use: CLAWKEEP_PASSWORD=xxx clawkeep backup set-password'));
+    console.error(chalk.dim('  Or:  clawkeep backup set-password -p <password>'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Setting encryption password...').start();
+  try {
+    bm.setPassword(password);
+    spinner.succeed('Encryption password set');
+    console.log(chalk.dim('  Password hash stored (password itself is never saved)'));
+  } catch (err) {
+    spinner.fail('Failed to set password');
+    console.error(chalk.red('  ' + err.message));
+    process.exit(1);
+  }
+}
+
+async function doSync(bm, opts) {
+  const cfg = bm.getConfig();
+  const password = cfg.target === 'local' ? getPassword(opts) : null;
+
+  if (cfg.target === 'local' && !password) {
+    console.error(chalk.red('  Password required for encrypted sync.'));
+    console.error(chalk.dim('  Use: CLAWKEEP_PASSWORD=xxx clawkeep backup sync'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Syncing to backup target...').start();
+  try {
+    const result = await bm.sync(password);
+    if (result.synced === false) {
+      spinner.succeed(result.message || 'Already up to date');
+    } else {
+      spinner.succeed('Synced to backup target');
+      if (result.chunkCount) {
+        console.log(chalk.dim(`  Chunks: ${result.chunkCount} \u2022 Size: ${fmtSize(result.totalSize || 0)}`));
+      }
+    }
+    if (result.lastSync) {
+      console.log(chalk.dim(`  Last sync: ${result.lastSync}`));
+    }
+  } catch (err) {
+    spinner.fail('Sync failed');
+    console.error(chalk.red('  ' + err.message));
+    process.exit(1);
+  }
+}
+
+async function doPull(bm) {
+  const spinner = ora('Pulling from backup target...').start();
+  try {
+    await bm.pull();
+    spinner.succeed('Pulled from backup target');
+  } catch (err) {
+    spinner.fail('Pull failed');
+    console.error(chalk.red('  ' + err.message));
+    process.exit(1);
+  }
+}
+
+async function doTest(bm) {
+  const spinner = ora('Testing connection...').start();
+  try {
+    const result = await bm.test();
+    if (result.ok) {
+      spinner.succeed(`${result.message}${result.latencyMs ? ` (${result.latencyMs}ms)` : ''}`);
+    } else {
+      spinner.fail(result.message);
+    }
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}
+
+async function doCompact(bm, opts) {
+  const password = getPassword(opts);
+  if (!password) {
+    console.error(chalk.red('  Password required for compact.'));
+    console.error(chalk.dim('  Use: CLAWKEEP_PASSWORD=xxx clawkeep backup compact'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Compacting backup chunks...').start();
+  try {
+    const result = await bm.compact(password);
+    if (result.compacted === false) {
+      spinner.succeed(result.message || 'Nothing to compact');
+    } else {
+      spinner.succeed(`Compacted ${result.oldChunks} chunks into 1`);
+      console.log(chalk.dim(`  New size: ${fmtSize(result.newSize || 0)}`));
+    }
+  } catch (err) {
+    spinner.fail('Compact failed');
+    console.error(chalk.red('  ' + err.message));
+    process.exit(1);
+  }
+}
+
+async function doRestore(args, opts) {
+  const sourcePath = opts.path || (args && args[0]);
+  if (!sourcePath) {
+    console.error(chalk.red('  Usage: clawkeep backup restore <backup-path> -d <dest>'));
+    process.exit(1);
+  }
+
+  const password = getPassword(opts);
+  if (!password) {
+    console.error(chalk.red('  Password required for restore.'));
+    console.error(chalk.dim('  Use: CLAWKEEP_PASSWORD=xxx clawkeep backup restore <path>'));
+    process.exit(1);
+  }
+
+  const destDir = path.resolve(opts.dir || '.');
+  const spinner = ora('Restoring from encrypted backup...').start();
+  try {
+    const result = await BackupManager.restoreFromBackup(sourcePath, destDir, password);
+    spinner.succeed('Restored from backup');
+    console.log(chalk.dim(`  Chunks: ${result.chunks} \u2022 Commits: ${result.totalCommits}`));
+    console.log(chalk.dim(`  Restored to: ${destDir}`));
+  } catch (err) {
+    spinner.fail('Restore failed');
+    console.error(chalk.red('  ' + err.message));
+    process.exit(1);
+  }
+}
+
+function fmtSize(b) {
+  if (b < 1024) return b + ' B';
+  if (b < 1048576) return (b / 1024).toFixed(1) + ' KB';
+  return (b / 1048576).toFixed(1) + ' MB';
+}

package/src/commands/diff.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const chalk = require('chalk');
+const path = require('path');
+const ClawGit = require('../core/git');
+
+module.exports = async function diff(opts) {
+  const dir = path.resolve(opts.dir || '.');
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (!(await claw.isInitialized())) {
+      console.error(chalk.red('ClawKeep not initialized. Run `clawkeep init` first.'));
+      process.exit(1);
+    }
+
+    const result = await claw.diff(opts.stat);
+
+    if (!result || result.trim() === '') {
+      console.log(chalk.dim('No changes since last backup.'));
+      return;
+    }
+
+    // Colorize diff output
+    const lines = result.split('\n');
+    for (const line of lines) {
+      if (line.startsWith('+') && !line.startsWith('+++')) {
+        console.log(chalk.green(line));
+      } else if (line.startsWith('-') && !line.startsWith('---')) {
+        console.log(chalk.red(line));
+      } else if (line.startsWith('@@')) {
+        console.log(chalk.cyan(line));
+      } else if (line.startsWith('diff')) {
+        console.log(chalk.bold(line));
+      } else {
+        console.log(line);
+      }
+    }
+  } catch (err) {
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+};

package/src/commands/export.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const ClawGit = require('../core/git');
+const { exportEncrypted } = require('../core/crypto');
+
+module.exports = async function exportCmd(opts) {
+  const dir = path.resolve(opts.dir || '.');
+  const spinner = ora('Exporting encrypted archive...').start();
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (!(await claw.isInitialized())) {
+      spinner.fail('ClawKeep not initialized. Run `clawkeep init` first.');
+      process.exit(1);
+    }
+
+    // Get password
+    const password = opts.password || process.env.CLAWKEEP_PASSWORD;
+    if (!password) {
+      spinner.fail('Password required. Use -p <password> or set CLAWKEEP_PASSWORD');
+      process.exit(1);
+    }
+
+    // Default output path
+    const config = claw.loadConfig();
+    const agentName = config.agentName || 'agent';
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+    const outputPath = opts.output || path.join(process.cwd(), `${agentName}-${timestamp}.clawkeep.enc`);
+
+    // Take a snap first to capture latest state
+    spinner.text = 'Capturing latest state...';
+    await claw.snap('export: pre-export backup');
+
+    // Export
+    spinner.text = 'Encrypting archive...';
+    const result = await exportEncrypted(dir, outputPath, password);
+
+    const sizeMB = (result.size / 1024 / 1024).toFixed(2);
+    spinner.succeed('Encrypted archive exported!');
+    console.log('');
+    console.log(`  📦 ${chalk.cyan(result.path)}`);
+    console.log(`  Size: ${chalk.yellow(sizeMB + ' MB')}`);
+    console.log(`  Encryption: ${chalk.green('AES-256-CTR + scrypt')}`);
+    console.log('');
+    console.log(chalk.yellow('  ⚠️  Don\'t lose the password. We can\'t recover it.'));
+  } catch (err) {
+    spinner.fail('Export failed');
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+};

package/src/commands/import.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const { importEncrypted } = require('../core/crypto');
+
+module.exports = async function importCmd(file, opts) {
+  const targetDir = path.resolve(opts.dir || '.');
+  const spinner = ora('Importing from encrypted archive...').start();
+
+  try {
+    const archivePath = path.resolve(file);
+
+    // Get password
+    const password = opts.password || process.env.CLAWKEEP_PASSWORD;
+    if (!password) {
+      spinner.fail('Password required. Use -p <password> or set CLAWKEEP_PASSWORD');
+      process.exit(1);
+    }
+
+    spinner.text = 'Decrypting and extracting...';
+    const result = await importEncrypted(archivePath, targetDir, password);
+
+    spinner.succeed('Import complete!');
+    console.log('');
+    console.log(`  📂 Restored to: ${chalk.cyan(result.path)}`);
+    console.log(chalk.dim('  Your full history and memory are restored.'));
+    console.log(chalk.dim('  Run `clawkeep log` to see backup history.'));
+  } catch (err) {
+    spinner.fail('Import failed');
+    if (err.message.includes('incorrect header check') || err.message.includes('bad decrypt')) {
+      console.error(chalk.red('  Wrong password or corrupted archive.'));
+    } else {
+      console.error(chalk.red(err.message));
+    }
+    process.exit(1);
+  }
+};

package/src/commands/init.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const ClawGit = require('../core/git');
+
+module.exports = async function init(opts) {
+  const dir = path.resolve(opts.dir || '.');
+  const spinner = ora('Initializing ClawKeep...').start();
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (await claw.isInitialized()) {
+      spinner.warn('ClawKeep is already initialized here.');
+      console.log(chalk.dim('  Run `clawkeep status` for details.'));
+      return;
+    }
+
+    const config = await claw.init();
+
+    // Take initial backup
+    spinner.text = 'Taking initial backup...';
+    const result = await claw.snap('initial backup');
+
+    spinner.succeed(chalk.bold('ClawKeep initialized!'));
+    console.log('');
+    console.log(chalk.bold.cyan('  🐾 Directory is now backed up'));
+    console.log('');
+    if (result) {
+      console.log(`  ${chalk.dim('Tracked')}     ${chalk.white(result.summary.changed + ' files')}`);
+      console.log(`  ${chalk.dim('Backup')}      ${chalk.yellow(result.hash.substring(0, 8))}`);
+    }
+    console.log('');
+    console.log(chalk.dim('  Next steps:'));
+    console.log(chalk.dim('  $ clawkeep watch          Auto-backup on file changes'));
+    console.log(chalk.dim('  $ clawkeep backup local   Set up backup target'));
+    console.log(chalk.dim('  $ clawkeep snap -m "..."  Manual backup'));
+    console.log('');
+  } catch (err) {
+    spinner.fail('Failed to initialize');
+    console.error(chalk.red('  ' + err.message));
+    process.exit(1);
+  }
+};

package/src/commands/log.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const chalk = require('chalk');
+const path = require('path');
+const ClawGit = require('../core/git');
+
+module.exports = async function log(opts) {
+  const dir = path.resolve(opts.dir || '.');
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (!(await claw.isInitialized())) {
+      console.error(chalk.red('Not initialized. Run `clawkeep init` first.'));
+      process.exit(1);
+    }
+
+    const entries = await claw.log(parseInt(opts.limit) || 20);
+
+    if (entries.length === 0) {
+      console.log(chalk.dim('No backups yet.'));
+      return;
+    }
+
+    // JSON output
+    if (opts.json) {
+      console.log(JSON.stringify(entries, null, 2));
+      return;
+    }
+
+    console.log('');
+    console.log(chalk.bold(`  📋 ${entries.length} backup${entries.length > 1 ? 's' : ''}`));
+    console.log('');
+
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const hash = chalk.yellow(entry.hash.substring(0, 8));
+      const date = _formatDate(entry.date);
+      const msg = entry.message;
+      const isFirst = i === 0;
+
+      if (opts.oneline) {
+        console.log(`  ${hash} ${msg} ${chalk.dim(date)}`);
+      } else {
+        const marker = isFirst ? chalk.green('●') : chalk.dim('○');
+        console.log(`  ${marker} ${hash} — ${msg}`);
+        console.log(`  ${chalk.dim('│')} ${chalk.dim(date)}`);
+        if (i < entries.length - 1) {
+          console.log(`  ${chalk.dim('│')}`);
+        }
+      }
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+};
+
+function _formatDate(dateStr) {
+  try {
+    const d = new Date(dateStr);
+    const now = new Date();
+    const diffMs = now - d;
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMins < 1) return 'just now';
+    if (diffMins < 60) return `${diffMins}m ago`;
+    if (diffHours < 24) return `${diffHours}h ago`;
+    if (diffDays < 7) return `${diffDays}d ago`;
+    return d.toISOString().substring(0, 16).replace('T', ' ');
+  } catch {
+    return dateStr;
+  }
+}

package/src/commands/pull.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const ClawGit = require('../core/git');
+
+module.exports = async function pull(opts) {
+  const dir = path.resolve(opts.dir || '.');
+  const spinner = ora('Pulling from remote...').start();
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (!(await claw.isInitialized())) {
+      spinner.fail('ClawKeep not initialized. Run `clawkeep init` first.');
+      process.exit(1);
+    }
+
+    const config = claw.loadConfig();
+    if (!config.remote) {
+      spinner.fail('No remote configured. Use `clawkeep push -r <url>` first.');
+      process.exit(1);
+    }
+
+    await claw.pull();
+
+    spinner.succeed('Pulled from remote!');
+  } catch (err) {
+    spinner.fail('Pull failed');
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+};

package/src/commands/push.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const ClawGit = require('../core/git');
+
+module.exports = async function push(opts) {
+  const dir = path.resolve(opts.dir || '.');
+  const spinner = ora('Pushing to remote...').start();
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (!(await claw.isInitialized())) {
+      spinner.fail('ClawKeep not initialized. Run `clawkeep init` first.');
+      process.exit(1);
+    }
+
+    // Set remote if provided
+    if (opts.remote) {
+      spinner.text = 'Setting remote...';
+      await claw.setRemote(opts.remote);
+    }
+
+    const config = claw.loadConfig();
+    if (!config.remote && !opts.remote) {
+      spinner.fail('No remote configured. Use `clawkeep push -r <url>`');
+      process.exit(1);
+    }
+
+    spinner.text = 'Pushing backups...';
+    await claw.push();
+
+    spinner.succeed('Pushed to remote!');
+    console.log(chalk.dim(`  Remote: ${config.remote || opts.remote}`));
+  } catch (err) {
+    spinner.fail('Push failed');
+    console.error(chalk.red(err.message));
+    if (err.message.includes('Authentication')) {
+      console.log(chalk.dim('  Hint: Make sure your remote URL includes credentials or SSH key is set up.'));
+    }
+    process.exit(1);
+  }
+};

package/src/commands/restore.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const ClawGit = require('../core/git');
+
+module.exports = async function restore(ref, opts) {
+  const dir = path.resolve(opts.dir || '.');
+  const spinner = ora('Restoring...').start();
+
+  try {
+    const claw = new ClawGit(dir);
+
+    if (!(await claw.isInitialized())) {
+      spinner.fail('ClawKeep not initialized. Run `clawkeep init` first.');
+      process.exit(1);
+    }
+
+    if (!ref) {
+      spinner.fail('Please specify a backup reference (hash or HEAD~N).');
+      console.log(chalk.dim('  Example: clawkeep restore abc123'));
+      console.log(chalk.dim('  Example: clawkeep restore HEAD~3'));
+      console.log(chalk.dim('  Run `clawkeep log` to see available backups.'));
+      process.exit(1);
+    }
+
+    await claw.restore(ref, opts.hard);
+
+    if (opts.hard) {
+      spinner.succeed(`Hard restore to ${chalk.cyan(ref.substring(0, 8))}`);
+      console.log(chalk.yellow('  ⚠️  Current changes were discarded.'));
+    } else {
+      spinner.succeed(`Restored to ${chalk.cyan(ref.substring(0, 8))} (new backup created)`);
+      console.log(chalk.dim('  Your history is preserved. The restore is a new backup.'));
+    }
+  } catch (err) {
+    spinner.fail('Restore failed');
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+};