@any-sync/cli 0.2.0

package/lib/init.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Create a config file with the given mappings.
+ * If config already exists, returns the path without overwriting.
+ */
+function init(configPath, repo, branch, mappings) {
+  // Validate repo format
+  if (!/^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/.test(repo)) {
+    throw new Error('Invalid repo format. Use owner/repo (e.g., myuser/my-sync-repo)');
+  }
+
+  // Validate branch name
+  if (!/^[a-zA-Z0-9._\/-]+$/.test(branch)) {
+    throw new Error('Invalid branch name. Use alphanumeric characters, hyphens, underscores, dots, or slashes.');
+  }
+
+  // If config already exists, return path
+  if (fs.existsSync(configPath)) {
+    return configPath;
+  }
+
+  // Create parent directory
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+
+  // Build config with repo/branch applied to each mapping
+  const config = {
+    mappings: mappings.map(m => ({
+      name: m.name,
+      repo,
+      branch,
+      sourcePath: m.sourcePath,
+      destPath: m.destPath,
+      ...(m.include ? { include: m.include } : {}),
+      ...(m.exclude ? { exclude: m.exclude } : {}),
+    })),
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  return configPath;
+}
+
+/**
+ * Return default mappings for a known preset.
+ * Returns null for unknown presets.
+ */
+function getPresetMappings(preset) {
+  const os = require('os');
+
+  switch (preset) {
+    case 'claude':
+      return [
+        {
+          name: 'claude-skills',
+          sourcePath: 'skills',
+          destPath: '~/.claude/skills',
+          include: ['**/*.md'],
+        },
+        { name: 'claude-memory', sourcePath: 'memory', destPath: '~/.claude/memory' },
+        {
+          name: 'claude-settings',
+          sourcePath: 'settings',
+          destPath: '~/.claude',
+          include: ['settings.json'],
+        },
+      ];
+
+    case 'openclaw': {
+      let workspace =
+        process.env.OPENCLAW_WORKSPACE || path.join(os.homedir(), '.openclaw', 'workspace');
+      const profile = process.env.OPENCLAW_PROFILE;
+      if (profile && profile !== 'default') {
+        workspace = path.join(os.homedir(), '.openclaw', `workspace-${profile}`);
+      }
+      return [
+        {
+          name: 'workspace-skills',
+          sourcePath: 'skills',
+          destPath: path.join(workspace, 'skills'),
+        },
+        {
+          name: 'workspace-memory',
+          sourcePath: 'memory',
+          destPath: path.join(workspace, 'memory'),
+        },
+        {
+          name: 'workspace-config',
+          sourcePath: 'config',
+          destPath: workspace,
+          include: ['AGENTS.md', 'SOUL.md', 'USER.md', 'TOOLS.md', 'IDENTITY.md'],
+        },
+      ];
+    }
+
+    default:
+      return null;
+  }
+}
+
+module.exports = { init, getPresetMappings };

package/lib/lockfile.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const EMPTY_DATA = { version: 1, files: {}, lastSync: {} };
+
+class Lockfile {
+  constructor(filePath) {
+    this._path = filePath;
+    this._data = { ...EMPTY_DATA, files: {}, lastSync: {} };
+  }
+
+  static load(filePath) {
+    const lf = new Lockfile(filePath);
+    if (fs.existsSync(filePath)) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (raw.version === 1 && raw.files && raw.lastSync) {
+          lf._data = raw;
+        }
+      } catch {
+        // Invalid file — use empty data
+      }
+    }
+    return lf;
+  }
+
+  save() {
+    const tmp = this._path + '.' + crypto.randomUUID();
+    fs.writeFileSync(tmp, JSON.stringify(this._data, null, 2) + '\n', 'utf8');
+    fs.renameSync(tmp, this._path);
+  }
+
+  getEntry(key) {
+    return this._data.files[key] || null;
+  }
+
+  setEntry(key, remoteSha, localHash) {
+    this._data.files[key] = {
+      remoteSha,
+      localHash,
+      syncedAt: new Date().toISOString().replace(/\.\d{3}Z$/, '.000Z'),
+    };
+  }
+
+  getEntriesForMapping(name) {
+    const prefix = name + '::';
+    const result = {};
+    for (const [key, value] of Object.entries(this._data.files)) {
+      if (key.startsWith(prefix)) {
+        result[key.slice(prefix.length)] = value;
+      }
+    }
+    return result;
+  }
+
+  setLastSync(name) {
+    this._data.lastSync[name] = new Date().toISOString().replace(/\.\d{3}Z$/, '.000Z');
+  }
+
+  getLastSync(name) {
+    return this._data.lastSync[name] || null;
+  }
+}
+
+function makeKey(mapping, relpath) {
+  return mapping + '::' + relpath;
+}
+
+function hashFile(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+module.exports = { Lockfile, makeKey, hashFile };

package/lib/pull.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { Lockfile, makeKey, hashFile } = require('./lockfile');
+const { ghApiRetry } = require('./gh');
+const { matchesAny } = require('./glob');
+const { loadConfig, parseMapping } = require('./config');
+const { checkAuth } = require('./auth');
+
+/**
+ * Pull files from GitHub.
+ * Returns: { pulled: [...], conflicts: [...], skipped: [...] }
+ */
+function pull(configPath, lockfilePath) {
+  const config = loadConfig(configPath);
+  const token = checkAuth();
+  process.env.GITHUB_TOKEN = token;
+
+  const lf = Lockfile.load(lockfilePath);
+  const pulled = [];
+  const conflicts = [];
+  const skipped = [];
+
+  for (const raw of config.mappings) {
+    const m = parseMapping(raw);
+    const [owner, repoName] = m.repo.split('/');
+    const prefix = m.sourcePath ? m.sourcePath + '/' : '';
+
+    // Fetch recursive tree
+    let treeOutput;
+    try {
+      treeOutput = ghApiRetry([
+        `/repos/${owner}/${repoName}/git/trees/${m.branch}?recursive=1`,
+        '--jq', '.tree[] | select(.type == "blob") | [.path, .sha] | @tsv',
+      ]);
+    } catch (err) {
+      process.stderr.write(`Error: Failed to fetch tree for ${m.repo} branch ${m.branch}\n`);
+      continue;
+    }
+
+    if (!treeOutput) {
+      lf.setLastSync(m.name);
+      continue;
+    }
+
+    const entries = treeOutput.split('\n').filter(Boolean).map(line => {
+      const [filePath, sha] = line.split('\t');
+      return { path: filePath, sha };
+    });
+
+    for (const entry of entries) {
+      // Filter by prefix
+      if (prefix && !entry.path.startsWith(prefix)) continue;
+
+      const relPath = prefix ? entry.path.slice(prefix.length) : entry.path;
+
+      // Apply include filter
+      if (m.include.length > 0 && !matchesAny(m.include, relPath)) continue;
+
+      // Apply exclude filter
+      if (m.exclude.length > 0 && matchesAny(m.exclude, relPath)) continue;
+
+      const lockKey = makeKey(m.name, relPath);
+      const existing = lf.getEntry(lockKey);
+      const localFile = path.join(m.destPath, relPath);
+
+      if (existing) {
+        // Remote unchanged → skip
+        if (existing.remoteSha === entry.sha) {
+          skipped.push({ file: relPath, mapping: m.name, reason: 'unchanged' });
+          continue;
+        }
+
+        // Remote changed — check if local also changed
+        if (fs.existsSync(localFile)) {
+          const currentHash = hashFile(localFile);
+          if (currentHash !== existing.localHash) {
+            conflicts.push({ file: relPath, mapping: m.name });
+            continue;
+          }
+        }
+      }
+
+      // Download blob
+      let blobContent;
+      try {
+        blobContent = ghApiRetry([
+          `/repos/${owner}/${repoName}/git/blobs/${entry.sha}`,
+          '--jq', '.content',
+        ]);
+      } catch (err) {
+        process.stderr.write(`Error: Failed to download blob for ${relPath}\n`);
+        continue;
+      }
+
+      // Write file atomically
+      const dir = path.dirname(localFile);
+      fs.mkdirSync(dir, { recursive: true });
+      const decoded = Buffer.from(blobContent.trim(), 'base64');
+      const tmp = localFile + '.' + require('crypto').randomUUID();
+      fs.writeFileSync(tmp, decoded);
+      fs.renameSync(tmp, localFile);
+
+      // Update lockfile
+      const newHash = hashFile(localFile);
+      lf.setEntry(lockKey, entry.sha, newHash);
+      pulled.push({ file: relPath, mapping: m.name });
+    }
+
+    lf.setLastSync(m.name);
+  }
+
+  lf.save();
+  return { pulled, conflicts, skipped };
+}
+
+module.exports = { pull };

package/lib/push.js

@@ -0,0 +1,192 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { Lockfile, makeKey, hashFile } = require('./lockfile');
+const { ghApiRetry } = require('./gh');
+const { matchesAny } = require('./glob');
+const { loadConfig, parseMapping } = require('./config');
+const { checkAuth } = require('./auth');
+
+/**
+ * Walk a directory recursively, returning relative file paths.
+ */
+function walkDir(dir) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true, recursive: true });
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      // entry.parentPath is available in Node 20+, fallback to entry.path
+      const parent = entry.parentPath || entry.path;
+      const fullPath = path.join(parent, entry.name);
+      const relPath = path.relative(dir, fullPath).split(path.sep).join('/');
+      results.push(relPath);
+    }
+  }
+  return results;
+}
+
+/**
+ * Push local changes to GitHub.
+ * Returns: { pushed: [...], branch: "..." }
+ */
+function push(configPath, lockfilePath) {
+  const config = loadConfig(configPath);
+  const token = checkAuth();
+  process.env.GITHUB_TOKEN = token;
+
+  const lf = Lockfile.load(lockfilePath);
+  const allPushed = [];
+  let lastBranch = 'main';
+
+  for (const raw of config.mappings) {
+    const m = parseMapping(raw);
+    const [owner, repoName] = m.repo.split('/');
+    lastBranch = m.branch;
+
+    if (!fs.existsSync(m.destPath)) continue;
+
+    const localFiles = walkDir(m.destPath);
+    const treeEntries = [];
+
+    for (const relPath of localFiles) {
+      // Apply include filter
+      if (m.include.length > 0 && !matchesAny(m.include, relPath)) continue;
+
+      // Apply exclude filter
+      if (m.exclude.length > 0 && matchesAny(m.exclude, relPath)) continue;
+
+      const localFile = path.join(m.destPath, relPath);
+      const lockKey = makeKey(m.name, relPath);
+      const existing = lf.getEntry(lockKey);
+      const currentHash = hashFile(localFile);
+
+      // Check if changed
+      let isChanged = false;
+      if (!existing) {
+        isChanged = true; // New file
+      } else if (currentHash !== existing.localHash) {
+        isChanged = true; // Modified
+      }
+
+      if (!isChanged) continue;
+
+      // Construct repo path
+      const repoPath = m.sourcePath ? m.sourcePath + '/' + relPath : relPath;
+
+      // Create blob (base64 encoded, piped via stdin)
+      const content = fs.readFileSync(localFile).toString('base64');
+      const blobPayload = JSON.stringify({ content, encoding: 'base64' });
+
+      let blobSha;
+      try {
+        blobSha = ghApiRetry(
+          [`/repos/${owner}/${repoName}/git/blobs`, '--input', '-', '--jq', '.sha'],
+          { input: blobPayload }
+        );
+      } catch (err) {
+        process.stderr.write(`Error: Failed to create blob for ${relPath}\n`);
+        process.exit(1);
+      }
+
+      treeEntries.push({ path: repoPath, mode: '100644', type: 'blob', sha: blobSha });
+      allPushed.push({ file: relPath, mapping: m.name, blobSha, localHash: currentHash });
+    }
+
+    if (treeEntries.length === 0) continue;
+
+    // Get current commit SHA
+    let commitSha;
+    try {
+      commitSha = ghApiRetry([
+        `/repos/${owner}/${repoName}/git/ref/heads/${m.branch}`,
+        '--jq', '.object.sha',
+      ]);
+    } catch (err) {
+      process.stderr.write(`Error: Failed to get commit SHA for branch ${m.branch}\n`);
+      process.exit(1);
+    }
+
+    // Get base tree SHA
+    let baseTreeSha;
+    try {
+      baseTreeSha = ghApiRetry([
+        `/repos/${owner}/${repoName}/git/commits/${commitSha}`,
+        '--jq', '.tree.sha',
+      ]);
+    } catch (err) {
+      process.stderr.write('Error: Failed to get base tree SHA\n');
+      process.exit(1);
+    }
+
+    // Create new tree
+    const treePayload = JSON.stringify({ base_tree: baseTreeSha, tree: treeEntries });
+    let newTreeSha;
+    try {
+      newTreeSha = ghApiRetry(
+        [`/repos/${owner}/${repoName}/git/trees`, '--input', '-', '--jq', '.sha'],
+        { input: treePayload }
+      );
+    } catch (err) {
+      process.stderr.write('Error: Failed to create tree\n');
+      process.exit(1);
+    }
+
+    // Create commit
+    let commitMsg;
+    if (treeEntries.length === 1) {
+      commitMsg = `sync: Update ${treeEntries[0].path} via Any Sync`;
+    } else {
+      commitMsg = `sync: Update ${treeEntries.length} file(s) in ${m.sourcePath} via Any Sync`;
+    }
+
+    const commitPayload = JSON.stringify({
+      message: commitMsg,
+      tree: newTreeSha,
+      parents: [commitSha],
+    });
+
+    let newCommitSha;
+    try {
+      newCommitSha = ghApiRetry(
+        [`/repos/${owner}/${repoName}/git/commits`, '--input', '-', '--jq', '.sha'],
+        { input: commitPayload }
+      );
+    } catch (err) {
+      process.stderr.write('Error: Failed to create commit\n');
+      process.exit(1);
+    }
+
+    // Update branch ref
+    try {
+      ghApiRetry([
+        '-X', 'PATCH',
+        `/repos/${owner}/${repoName}/git/refs/heads/${m.branch}`,
+        '-f', `sha=${newCommitSha}`,
+      ]);
+    } catch (err) {
+      process.stderr.write('Error: Failed to update branch ref. Another push may have occurred — try pulling first.\n');
+      process.exit(1);
+    }
+
+    // Update lockfile for pushed files
+    for (const p of allPushed) {
+      if (p.mapping !== m.name) continue;
+      const lockKey = makeKey(m.name, p.file);
+      lf.setEntry(lockKey, p.blobSha, p.localHash);
+    }
+
+    lf.setLastSync(m.name);
+  }
+
+  lf.save();
+  return {
+    pushed: allPushed.map(p => ({ file: p.file, mapping: p.mapping })),
+    branch: lastBranch,
+  };
+}
+
+module.exports = { push };

package/lib/reset.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const fs = require('fs');
+
+/**
+ * Delete config and lockfile.
+ * Returns: { deletedConfig, configPath, deletedLockfile, lockfilePath }
+ */
+function reset(configPath, lockfilePath) {
+  let deletedConfig = false;
+  let deletedLockfile = false;
+
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+    deletedConfig = true;
+  }
+
+  if (fs.existsSync(lockfilePath)) {
+    fs.unlinkSync(lockfilePath);
+    deletedLockfile = true;
+  }
+
+  return { deletedConfig, configPath, deletedLockfile, lockfilePath };
+}
+
+module.exports = { reset };

package/lib/status.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { Lockfile, makeKey, hashFile } = require('./lockfile');
+const { matchesAny } = require('./glob');
+const { loadConfig, parseMapping } = require('./config');
+
+/**
+ * Walk a directory recursively, returning relative file paths.
+ */
+function walkDir(dir) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  const entries = fs.readdirSync(dir, { withFileTypes: true, recursive: true });
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      const parent = entry.parentPath || entry.path;
+      const fullPath = path.join(parent, entry.name);
+      results.push(path.relative(dir, fullPath).split(path.sep).join('/'));
+    }
+  }
+  return results;
+}
+
+/**
+ * Get sync status.
+ * Returns: { auth: {...}, config: {...}, mappings: [...] }
+ */
+function status(configPath, lockfilePath) {
+  // Check auth
+  let authMethod = 'none';
+  let authUser = '';
+
+  if (process.env.GITHUB_TOKEN) {
+    authMethod = 'token';
+    try {
+      authUser = execFileSync('gh', ['api', '/user', '--jq', '.login'], {
+        encoding: 'utf8',
+      }).trim();
+    } catch {
+      authUser = 'unknown';
+    }
+  } else {
+    try {
+      execFileSync('gh', ['auth', 'token'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+      authMethod = 'gh';
+      try {
+        authUser = execFileSync('gh', ['api', '/user', '--jq', '.login'], {
+          encoding: 'utf8',
+        }).trim();
+      } catch {
+        authUser = 'unknown';
+      }
+    } catch {
+      // No auth
+    }
+  }
+
+  // Check config
+  let configValid = false;
+  let config = null;
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (Array.isArray(config.mappings)) {
+        configValid = true;
+      }
+    } catch {
+      // Invalid config
+    }
+  }
+
+  const lf = Lockfile.load(lockfilePath);
+  const mappings = [];
+
+  if (configValid && config) {
+    for (const raw of config.mappings) {
+      const m = parseMapping(raw);
+      const lastSync = lf.getLastSync(m.name);
+      const entries = lf.getEntriesForMapping(m.name);
+      const trackedFiles = Object.keys(entries).length;
+      const changes = [];
+
+      // Check tracked files for local modifications
+      for (const [relPath, entry] of Object.entries(entries)) {
+        const localFile = path.join(m.destPath, relPath);
+        if (fs.existsSync(localFile)) {
+          const currentHash = hashFile(localFile);
+          if (currentHash !== entry.localHash) {
+            changes.push({ file: relPath, type: 'modified' });
+          }
+        }
+      }
+
+      // Check for new files
+      if (fs.existsSync(m.destPath)) {
+        const localFiles = walkDir(m.destPath);
+        for (const relPath of localFiles) {
+          // Apply include filter
+          if (m.include.length > 0 && !matchesAny(m.include, relPath)) continue;
+          // Apply exclude filter
+          if (m.exclude.length > 0 && matchesAny(m.exclude, relPath)) continue;
+
+          const lockKey = makeKey(m.name, relPath);
+          if (!lf.getEntry(lockKey)) {
+            changes.push({ file: relPath, type: 'new' });
+          }
+        }
+      }
+
+      mappings.push({
+        name: m.name,
+        repo: m.repo,
+        branch: m.branch,
+        lastSync,
+        trackedFiles,
+        changes,
+      });
+    }
+  }
+
+  return {
+    auth: { method: authMethod, user: authUser },
+    config: { path: configPath, valid: configValid },
+    mappings,
+  };
+}
+
+module.exports = { status };

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@any-sync/cli",
+  "version": "0.2.0",
+  "description": "CLI and core library for Any Sync — bidirectional GitHub file sync",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "bin": {
+    "any-sync": "bin/cli.js"
+  },
+  "license": "MIT",
+  "repository": "https://github.com/imink/any-sync",
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  }
+}