@any-sync/cli 0.2.0 → 0.2.5

package/bin/cli.js

@@ -6,12 +6,15 @@ const path = require('path');
 const pkg = require('../package.json');
 
 const COMMANDS = {
+  onboard: 'Interactive setup wizard',
   pull: 'Pull files from GitHub',
   push: 'Push local changes to GitHub',
   status: 'Show sync status',
   reset: 'Remove config and lockfile',
   auth: 'Check GitHub authentication',
   init: 'Create config file (use --preset for defaults)',
+  'update-config': 'Update config mappings (add include patterns)',
+  help: 'Show detailed command help',
 };
 
 function usage() {
@@ -19,7 +22,7 @@ function usage() {
   process.stdout.write('Usage: any-sync <command> [options]\n\n');
   process.stdout.write('Commands:\n');
   for (const [cmd, desc] of Object.entries(COMMANDS)) {
-    process.stdout.write(`  ${cmd.padEnd(10)} ${desc}\n`);
+    process.stdout.write(`  ${cmd.padEnd(16)} ${desc}\n`);
   }
   process.stdout.write('\nRun any-sync <command> --help for command-specific usage.\n');
 }
@@ -46,51 +49,59 @@ if (!COMMANDS[command]) {
 const lib = require('../lib');
 const cmdArgs = args.slice(1);
 
+function resolveConfigAndLock(cmdArgs) {
+  const configPath = cmdArgs[0] || lib.findConfig();
+  if (!configPath) {
+    process.stderr.write(
+      'No config found. Run "any-sync onboard" to set up, or pass a config path.\n',
+    );
+    process.exit(1);
+  }
+  const lockfilePath = cmdArgs[1] || path.join(path.dirname(configPath), '.any-sync.lock');
+  return { configPath, lockfilePath };
+}
+
 try {
   switch (command) {
     case 'pull': {
-      const configPath = cmdArgs[0];
-      const lockfilePath = cmdArgs[1] || '.any-sync.lock';
-      if (!configPath || cmdArgs.includes('--help')) {
-        process.stdout.write('Usage: any-sync pull <config-path> [lockfile-path]\n');
-        process.exit(cmdArgs.includes('--help') ? 0 : 1);
+      if (cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync pull [config-path] [lockfile-path]\n');
+        process.exit(0);
       }
+      const { configPath, lockfilePath } = resolveConfigAndLock(cmdArgs);
       const result = lib.pull(configPath, lockfilePath);
       process.stdout.write(JSON.stringify(result, null, 2) + '\n');
       break;
     }
 
     case 'push': {
-      const configPath = cmdArgs[0];
-      const lockfilePath = cmdArgs[1] || '.any-sync.lock';
-      if (!configPath || cmdArgs.includes('--help')) {
-        process.stdout.write('Usage: any-sync push <config-path> [lockfile-path]\n');
-        process.exit(cmdArgs.includes('--help') ? 0 : 1);
+      if (cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync push [config-path] [lockfile-path]\n');
+        process.exit(0);
       }
+      const { configPath, lockfilePath } = resolveConfigAndLock(cmdArgs);
       const result = lib.push(configPath, lockfilePath);
       process.stdout.write(JSON.stringify(result, null, 2) + '\n');
       break;
     }
 
     case 'status': {
-      const configPath = cmdArgs[0];
-      const lockfilePath = cmdArgs[1] || '.any-sync.lock';
-      if (!configPath || cmdArgs.includes('--help')) {
-        process.stdout.write('Usage: any-sync status <config-path> [lockfile-path]\n');
-        process.exit(cmdArgs.includes('--help') ? 0 : 1);
+      if (cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync status [config-path] [lockfile-path]\n');
+        process.exit(0);
       }
+      const { configPath, lockfilePath } = resolveConfigAndLock(cmdArgs);
       const result = lib.status(configPath, lockfilePath);
       process.stdout.write(JSON.stringify(result, null, 2) + '\n');
       break;
     }
 
     case 'reset': {
-      const configPath = cmdArgs[0];
-      const lockfilePath = cmdArgs[1] || '.any-sync.lock';
-      if (!configPath || cmdArgs.includes('--help')) {
-        process.stdout.write('Usage: any-sync reset <config-path> [lockfile-path]\n');
-        process.exit(cmdArgs.includes('--help') ? 0 : 1);
+      if (cmdArgs.includes('--help')) {
+        process.stdout.write('Usage: any-sync reset [config-path] [lockfile-path]\n');
+        process.exit(0);
       }
+      const { configPath, lockfilePath } = resolveConfigAndLock(cmdArgs);
       const result = lib.reset(configPath, lockfilePath);
       process.stdout.write(JSON.stringify(result, null, 2) + '\n');
       break;
@@ -148,6 +159,93 @@ try {
       process.stdout.write(result + '\n');
       break;
     }
+
+    case 'update-config': {
+      if (cmdArgs.includes('--help')) {
+        process.stdout.write(
+          'Usage: any-sync update-config <config-path> <mapping-name> --add-include <pattern> [--add-include <pattern> ...]\n',
+        );
+        process.exit(0);
+      }
+      const positional = [];
+      const addInclude = [];
+      for (let i = 0; i < cmdArgs.length; i++) {
+        if (cmdArgs[i] === '--add-include') {
+          addInclude.push(cmdArgs[++i]);
+        } else {
+          positional.push(cmdArgs[i]);
+        }
+      }
+      const configPath = positional[0];
+      const mappingName = positional[1];
+      if (!configPath || !mappingName || addInclude.length === 0) {
+        process.stderr.write(
+          'Usage: any-sync update-config <config-path> <mapping-name> --add-include <pattern> [--add-include <pattern> ...]\n',
+        );
+        process.exit(1);
+      }
+      const config = lib.loadConfig(configPath);
+      const mapping = config.mappings.find(m => m.name === mappingName);
+      if (!mapping) {
+        process.stderr.write(`Error: Mapping "${mappingName}" not found in config\n`);
+        process.exit(1);
+      }
+      if (!mapping.include) mapping.include = [];
+      for (const pattern of addInclude) {
+        if (!mapping.include.includes(pattern)) {
+          mapping.include.push(pattern);
+        }
+      }
+      lib.saveConfig(configPath, config);
+      process.stdout.write(JSON.stringify({ updated: mappingName, include: mapping.include }) + '\n');
+      break;
+    }
+
+    case 'help': {
+      const subcommand = cmdArgs[0];
+      if (!subcommand) {
+        usage();
+        process.exit(0);
+      }
+      const helpText = lib.commandHelp(subcommand);
+      if (!helpText) {
+        process.stderr.write(`Unknown command: ${subcommand}\n`);
+        process.stderr.write('Run any-sync --help for available commands.\n');
+        process.exit(1);
+      }
+      process.stdout.write(helpText + '\n');
+      break;
+    }
+
+    case 'onboard': {
+      if (cmdArgs.includes('--help')) {
+        const helpText = lib.commandHelp('onboard');
+        process.stdout.write(helpText + '\n');
+        process.exit(0);
+      }
+      const onboardOpts = {};
+      onboardOpts.presets = [];
+      for (let i = 0; i < cmdArgs.length; i++) {
+        if (cmdArgs[i] === '--repo') onboardOpts.repo = cmdArgs[++i];
+        else if (cmdArgs[i] === '--preset') onboardOpts.presets.push(cmdArgs[++i]);
+        else if (cmdArgs[i] === '--branch') onboardOpts.branch = cmdArgs[++i];
+        else if (cmdArgs[i] === '--config') onboardOpts.configPath = cmdArgs[++i];
+        else if (cmdArgs[i] === '--no-pull') onboardOpts.pull = false;
+        else if (cmdArgs[i] === '--force') onboardOpts.force = true;
+      }
+      if (onboardOpts.presets.length === 0) delete onboardOpts.presets;
+
+      lib
+        .onboard(onboardOpts)
+        .then((result) => {
+          process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+        })
+        .catch((err) => {
+          process.stderr.write('Error: ' + err.message + '\n');
+          process.exit(1);
+        });
+      break;
+    }
   }
 } catch (err) {
   process.stderr.write('Error: ' + err.message + '\n');

package/lib/config.js

@@ -56,4 +56,13 @@ function parseMapping(m) {
   };
 }
 
-module.exports = { loadConfig, findConfig, expandTilde, parseMapping };
+/**
+ * Save a config object to disk atomically.
+ */
+function saveConfig(configPath, config) {
+  const tmpPath = configPath + '.tmp.' + process.pid;
+  fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmpPath, configPath);
+}
+
+module.exports = { loadConfig, findConfig, expandTilde, parseMapping, saveConfig };

package/lib/help.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const COMMAND_HELP = {
+  pull: {
+    usage: 'any-sync pull [config-path] [lockfile-path]',
+    description:
+      'Download files from GitHub that changed since the last sync.\n' +
+      '  Detects conflicts when both local and remote have been modified.\n' +
+      '  If no config path is given, searches ~/.any-sync.json then ./.any-sync.json.',
+    options: [
+      { flag: '[config-path]', desc: 'Path to .any-sync.json (default: auto-detected)' },
+      { flag: '[lockfile-path]', desc: 'Path to lockfile (default: alongside config)' },
+    ],
+    examples: ['any-sync pull', 'any-sync pull ~/.any-sync.json', 'any-sync pull .any-sync.json ./my.lock'],
+  },
+
+  push: {
+    usage: 'any-sync push [config-path] [lockfile-path]',
+    description:
+      'Upload local file changes to GitHub.\n' +
+      '  Creates a new commit on the configured branch for each mapping with changes.\n' +
+      '  If no config path is given, searches ~/.any-sync.json then ./.any-sync.json.',
+    options: [
+      { flag: '[config-path]', desc: 'Path to .any-sync.json (default: auto-detected)' },
+      { flag: '[lockfile-path]', desc: 'Path to lockfile (default: alongside config)' },
+    ],
+    examples: ['any-sync push', 'any-sync push ~/.any-sync.json', 'any-sync push .any-sync.json ./my.lock'],
+  },
+
+  status: {
+    usage: 'any-sync status [config-path] [lockfile-path]',
+    description:
+      'Show sync status including auth method, config validity,\n' +
+      '  tracked files, local changes, and untracked files per mapping.\n' +
+      '  If no config path is given, searches ~/.any-sync.json then ./.any-sync.json.',
+    options: [
+      { flag: '[config-path]', desc: 'Path to .any-sync.json (default: auto-detected)' },
+      { flag: '[lockfile-path]', desc: 'Path to lockfile (default: alongside config)' },
+    ],
+    examples: ['any-sync status', 'any-sync status ~/.any-sync.json'],
+  },
+
+  reset: {
+    usage: 'any-sync reset [config-path] [lockfile-path]',
+    description:
+      'Remove config and lockfile to start fresh.\n' +
+      '  If no config path is given, searches ~/.any-sync.json then ./.any-sync.json.',
+    options: [
+      { flag: '[config-path]', desc: 'Path to .any-sync.json (default: auto-detected)' },
+      { flag: '[lockfile-path]', desc: 'Path to lockfile (default: alongside config)' },
+    ],
+    examples: ['any-sync reset', 'any-sync reset ~/.any-sync.json'],
+  },
+
+  auth: {
+    usage: 'any-sync auth',
+    description:
+      'Check GitHub authentication.\n' +
+      '  Looks for GITHUB_TOKEN env var first, then tries gh auth token.',
+    options: [],
+    examples: ['any-sync auth', 'GITHUB_TOKEN=ghp_xxx any-sync auth'],
+  },
+
+  init: {
+    usage: 'any-sync init <config-path> <repo> [branch] [--preset claude|openclaw]',
+    description:
+      'Create a .any-sync.json config file with preset mappings.\n' +
+      '  Skips if config already exists at the given path.',
+    options: [
+      { flag: '<config-path>', desc: 'Path to write config file (required)' },
+      { flag: '<repo>', desc: 'GitHub repo in owner/repo format (required)' },
+      { flag: '[branch]', desc: 'Branch to sync (default: main)' },
+      { flag: '--preset <name>', desc: 'Use preset mappings: claude, openclaw' },
+    ],
+    examples: [
+      'any-sync init ~/.any-sync.json myuser/sync-repo --preset claude',
+      'any-sync init .any-sync.json myuser/sync-repo main --preset openclaw',
+    ],
+  },
+
+  'update-config': {
+    usage: 'any-sync update-config <config-path> <mapping-name> --add-include <pattern>',
+    description:
+      'Add include patterns to an existing mapping.\n' +
+      '  Patterns can be specified multiple times.',
+    options: [
+      { flag: '<config-path>', desc: 'Path to .any-sync.json config file (required)' },
+      { flag: '<mapping-name>', desc: 'Name of the mapping to update (required)' },
+      { flag: '--add-include <pattern>', desc: 'Glob pattern to add (repeatable)' },
+    ],
+    examples: [
+      'any-sync update-config ~/.any-sync.json claude-skills --add-include "**/*.md"',
+      'any-sync update-config ~/.any-sync.json claude-config --add-include "rules/**" --add-include "agents/**"',
+    ],
+  },
+
+  onboard: {
+    usage: 'any-sync onboard [options]',
+    description:
+      'Interactive setup wizard. Guides you from zero to syncing:\n' +
+      '  checks prerequisites, detects tools, creates config, and pulls files.',
+    options: [
+      { flag: '--repo <owner/repo>', desc: 'GitHub repo (skip prompt)' },
+      { flag: '--preset <name>', desc: 'Tool/preset to enable: claude, openclaw, vscode (repeatable)' },
+      { flag: '--branch <name>', desc: 'Branch to sync (default: main)' },
+      { flag: '--config <path>', desc: 'Config file path (default: ~/.any-sync.json)' },
+      { flag: '--no-pull', desc: 'Skip initial pull' },
+      { flag: '--force', desc: 'Overwrite existing config without asking' },
+    ],
+    examples: [
+      'any-sync onboard',
+      'any-sync onboard --repo myuser/sync-repo --preset claude',
+      'any-sync onboard --repo myuser/sync-repo --preset claude --preset vscode',
+      'any-sync onboard --repo myuser/sync-repo --preset claude --no-pull',
+    ],
+  },
+
+  help: {
+    usage: 'any-sync help [command]',
+    description:
+      'Show detailed help for a command.\n' +
+      '  Without arguments, shows the list of all commands.',
+    options: [{ flag: '[command]', desc: 'Command to show help for' }],
+    examples: ['any-sync help', 'any-sync help pull', 'any-sync help onboard'],
+  },
+};
+
+/**
+ * Return formatted help text for a command, or null if unknown.
+ */
+function commandHelp(name) {
+  const entry = COMMAND_HELP[name];
+  if (!entry) return null;
+
+  let out = `any-sync ${name} — ${entry.description.split('\n')[0]}\n\n`;
+  out += `Usage: ${entry.usage}\n\n`;
+  out += `  ${entry.description}\n`;
+
+  if (entry.options.length > 0) {
+    out += '\nOptions:\n';
+    const maxFlag = Math.max(...entry.options.map((o) => o.flag.length));
+    for (const opt of entry.options) {
+      out += `  ${opt.flag.padEnd(maxFlag + 2)} ${opt.desc}\n`;
+    }
+  }
+
+  if (entry.examples.length > 0) {
+    out += '\nExamples:\n';
+    for (const ex of entry.examples) {
+      out += `  ${ex}\n`;
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Return the raw help data object for a command, or null if unknown.
+ */
+function getCommandHelp(name) {
+  return COMMAND_HELP[name] || null;
+}
+
+module.exports = { commandHelp, getCommandHelp };

package/lib/index.d.ts

@@ -31,6 +31,8 @@ export declare function parseMapping(m: Record<string, unknown>): {
   exclude: string[];
 };
 
+export declare function saveConfig(configPath: string, config: { mappings: Array<Record<string, unknown>> }): void;
+
 export declare function checkAuth(): string;
 
 export declare function pull(configPath: string, lockfilePath: string): {
@@ -54,6 +56,7 @@ export declare function status(configPath: string, lockfilePath: string): {
     lastSync: string | null;
     tracked: number;
     changes: Array<{ file: string; type: string }>;
+    untracked: Array<{ file: string }>;
   }>;
 };
 

package/lib/index.js

@@ -3,7 +3,7 @@
 const { Lockfile, makeKey, hashFile } = require('./lockfile');
 const { ghApi, ghApiRetry, getAuthToken } = require('./gh');
 const { globMatch, matchesAny } = require('./glob');
-const { loadConfig, findConfig, expandTilde, parseMapping } = require('./config');
+const { loadConfig, findConfig, expandTilde, parseMapping, saveConfig } = require('./config');
 const { checkAuth } = require('./auth');
 const { pull } = require('./pull');
 const { push } = require('./push');
@@ -11,6 +11,8 @@ const { status } = require('./status');
 const { reset } = require('./reset');
 const { init, getPresetMappings } = require('./init');
 const { autoPull, autoPush } = require('./hooks');
+const { onboard, detectTools, mergePresetMappings } = require('./onboard');
+const { commandHelp, getCommandHelp } = require('./help');
 
 module.exports = {
   // Lockfile
@@ -29,6 +31,7 @@ module.exports = {
   findConfig,
   expandTilde,
   parseMapping,
+  saveConfig,
   // Auth
   checkAuth,
   // Operations
@@ -41,4 +44,11 @@ module.exports = {
   getPresetMappings,
   autoPull,
   autoPush,
+  // Onboard
+  onboard,
+  detectTools,
+  mergePresetMappings,
+  // Help
+  commandHelp,
+  getCommandHelp,
 };

package/lib/init.js

@@ -59,12 +59,11 @@ function getPresetMappings(preset) {
           destPath: '~/.claude/skills',
           include: ['**/*.md'],
         },
-        { name: 'claude-memory', sourcePath: 'memory', destPath: '~/.claude/memory' },
         {
-          name: 'claude-settings',
-          sourcePath: 'settings',
+          name: 'claude-config',
+          sourcePath: '.claude',
           destPath: '~/.claude',
-          include: ['settings.json'],
+          include: ['settings.json', 'CLAUDE.md', 'rules/**/*.md', 'agents/**/*.md', 'memory/**'],
         },
       ];
 

package/lib/onboard.js

@@ -0,0 +1,322 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+const { execFileSync } = require('child_process');
+const { getPresetMappings } = require('./init');
+const { findConfig, saveConfig } = require('./config');
+const { getAuthToken } = require('./gh');
+const { pull } = require('./pull');
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function isToolInstalled(name) {
+  try {
+    execFileSync('which', [name], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ask(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+function write(output, text) {
+  output.write(text);
+}
+
+// ── Exported functions ───────────────────────────────────────────────────────
+
+/**
+ * Detect which tools are installed on the system.
+ */
+function detectTools() {
+  return {
+    gh: isToolInstalled('gh'),
+    claude: isToolInstalled('claude'),
+    openclaw: isToolInstalled('openclaw'),
+    code: isToolInstalled('code'),
+  };
+}
+
+/**
+ * Merge mappings from multiple presets into a single array.
+ */
+function mergePresetMappings(presetNames) {
+  const mappings = [];
+  for (const name of presetNames) {
+    const preset = getPresetMappings(name);
+    if (preset) mappings.push(...preset);
+  }
+  return mappings;
+}
+
+/**
+ * Interactive onboard wizard.
+ *
+ * @param {object} opts
+ * @param {string}   [opts.repo]       - GitHub repo (skip prompt)
+ * @param {string}   [opts.branch]     - Branch (default: 'main')
+ * @param {string[]} [opts.presets]    - Presets to enable (skip prompt)
+ * @param {boolean}  [opts.pull]       - Run initial pull (default: true)
+ * @param {string}   [opts.configPath] - Config path (default: ~/.any-sync.json)
+ * @param {boolean}  [opts.force]      - Overwrite existing config
+ * @param {NodeJS.ReadableStream} [opts.input]  - Input stream (default: stdin)
+ * @param {NodeJS.WritableStream} [opts.output] - Output stream (default: stderr)
+ */
+async function onboard(opts = {}) {
+  const input = opts.input || process.stdin;
+  const output = opts.output || process.stderr;
+  const configPath = opts.configPath || path.join(os.homedir(), '.any-sync.json');
+  const branch = opts.branch || 'main';
+  const doPull = opts.pull !== false;
+  const interactive = !opts.repo || !opts.presets;
+
+  // If interactive but not a TTY, bail
+  if (interactive && input === process.stdin && !process.stdin.isTTY) {
+    throw new Error(
+      'Interactive mode requires a terminal. Use --repo and --preset flags for non-interactive setup.',
+    );
+  }
+
+  const rl = interactive
+    ? readline.createInterface({ input, output, terminal: input.isTTY !== false })
+    : null;
+
+  try {
+    return await _runWizard({ rl, output, configPath, branch, doPull, opts });
+  } finally {
+    if (rl) rl.close();
+  }
+}
+
+async function _runWizard({ rl, output, configPath, branch, doPull, opts }) {
+  const result = {
+    configPath,
+    repo: null,
+    branch,
+    presets: [],
+    mappingCount: 0,
+    toolsDetected: [],
+    pullResult: null,
+    pluginInstructions: [],
+  };
+
+  // ── Step 1: Welcome ────────────────────────────────────────────────────────
+  write(output, '\nWelcome to Any Sync setup!\n');
+  write(output, 'This wizard will configure file sync between your tools and GitHub.\n\n');
+
+  // ── Step 2: Prerequisites ──────────────────────────────────────────────────
+  write(output, 'Checking prerequisites...\n');
+  const tools = detectTools();
+
+  const nodeVersion = process.versions.node;
+  const nodeMajor = parseInt(nodeVersion.split('.')[0], 10);
+  write(output, `  Node.js:    v${nodeVersion} ${nodeMajor >= 18 ? '(OK)' : '(WARNING: v18+ recommended)'}\n`);
+  write(output, `  gh CLI:     ${tools.gh ? 'installed (OK)' : 'not found'}\n`);
+  if (tools.claude) result.toolsDetected.push('claude');
+  if (tools.openclaw) result.toolsDetected.push('openclaw');
+  if (tools.code) result.toolsDetected.push('code');
+  write(output, `  Claude:     ${tools.claude ? 'detected' : 'not found'}\n`);
+  write(output, `  OpenClaw:   ${tools.openclaw ? 'detected' : 'not found'}\n`);
+  write(output, `  VS Code:    ${tools.code ? 'detected' : 'not found'}\n`);
+  write(output, '\n');
+
+  if (!tools.gh) {
+    throw new Error(
+      'gh CLI is required but not installed.\n' +
+        'Install it from https://cli.github.com/ then re-run: any-sync onboard',
+    );
+  }
+
+  // ── Step 3: Auth ───────────────────────────────────────────────────────────
+  const token = getAuthToken();
+  if (!token) {
+    throw new Error(
+      'GitHub authentication not found.\n' +
+        'Please authenticate using one of:\n' +
+        "  1. Run 'gh auth login'\n" +
+        '  2. Set GITHUB_TOKEN environment variable\n\n' +
+        'Then re-run: any-sync onboard',
+    );
+  }
+  write(output, '  GitHub auth: authenticated (OK)\n\n');
+
+  // ── Step 4: Existing config ────────────────────────────────────────────────
+  const existingConfig = findConfig();
+  if (existingConfig && !opts.force) {
+    if (rl) {
+      const overwrite = await ask(rl, `Existing config found at ${existingConfig}. Overwrite? [y/N]`, 'n');
+      if (overwrite.toLowerCase() !== 'y') {
+        write(output, 'Setup cancelled. Your existing config is unchanged.\n');
+        return result;
+      }
+    } else {
+      throw new Error(
+        `Config already exists at ${existingConfig}. Use --force to overwrite.`,
+      );
+    }
+  }
+
+  // ── Step 5: Repo ───────────────────────────────────────────────────────────
+  let repo = opts.repo;
+  if (!repo && rl) {
+    const repoRegex = /^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      repo = await ask(rl, 'GitHub sync repo (owner/repo format)');
+      if (repoRegex.test(repo)) break;
+      write(output, '  Invalid format. Use owner/repo (e.g., myuser/my-sync-repo)\n');
+      if (attempt === 2) throw new Error('Invalid repo format after 3 attempts.');
+      repo = null;
+    }
+  }
+  if (!repo) {
+    throw new Error('--repo is required in non-interactive mode.');
+  }
+  result.repo = repo;
+
+  // ── Step 6: Branch ─────────────────────────────────────────────────────────
+  if (rl && !opts.branch) {
+    result.branch = await ask(rl, 'Branch to sync', 'main');
+  }
+
+  // ── Step 7: Tool/preset selection ───────────────────────────────────────────
+  let presets = opts.presets;
+  let installVscode = false;
+  if (!presets && rl) {
+    write(output, '\nSelect tools to set up (comma-separated):\n');
+    const toolOptions = [
+      { key: '1', name: 'claude', label: 'skills, memory, settings', detected: tools.claude },
+      { key: '2', name: 'openclaw', label: 'workspace skills, memory, config', detected: tools.openclaw },
+      { key: '3', name: 'vscode', label: 'VS Code extension for sync', detected: tools.code },
+      { key: '4', name: 'custom', label: 'configure manually later', detected: false },
+    ];
+    const defaults = [];
+    for (const opt of toolOptions) {
+      const tag = opt.detected ? ' [detected]' : '';
+      write(output, `  ${opt.key}. ${opt.name.padEnd(12)} — ${opt.label}${tag}\n`);
+      if (opt.detected && opt.name !== 'custom') defaults.push(opt.key);
+    }
+    const defaultStr = defaults.length > 0 ? defaults.join(',') : '1';
+    const choice = await ask(rl, 'Choice', defaultStr);
+    const selected = choice.split(',').map((s) => s.trim());
+    presets = [];
+    for (const s of selected) {
+      const opt = toolOptions.find((o) => o.key === s);
+      if (!opt) continue;
+      if (opt.name === 'vscode') {
+        installVscode = true;
+      } else if (opt.name !== 'custom') {
+        presets.push(opt.name);
+      }
+    }
+  }
+  if (!presets) {
+    throw new Error('--preset is required in non-interactive mode.');
+  }
+  if (opts.presets && opts.presets.includes('vscode')) {
+    installVscode = true;
+    presets = presets.filter((p) => p !== 'vscode');
+  }
+  result.presets = presets;
+
+  // ── Step 8: Write config ───────────────────────────────────────────────────
+  const mappings = mergePresetMappings(presets);
+  const config = {
+    mappings: mappings.map((m) => ({
+      name: m.name,
+      repo,
+      branch: result.branch,
+      sourcePath: m.sourcePath,
+      destPath: m.destPath,
+      ...(m.include ? { include: m.include } : {}),
+      ...(m.exclude ? { exclude: m.exclude } : {}),
+    })),
+  };
+
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  saveConfig(configPath, config);
+  result.mappingCount = config.mappings.length;
+  write(output, `\nConfig written to ${configPath}\n`);
+
+  // ── Step 9: Initial pull ───────────────────────────────────────────────────
+  if (doPull && config.mappings.length > 0) {
+    write(output, '\nRunning initial pull...\n');
+    const lockfilePath = path.join(path.dirname(configPath), '.any-sync.lock');
+    try {
+      result.pullResult = pull(configPath, lockfilePath);
+      const pulled = result.pullResult.pulled || [];
+      write(output, `  Pulled ${pulled.length} file(s).\n`);
+    } catch (err) {
+      write(output, `  Pull failed: ${err.message}\n`);
+      write(output, '  Config was saved successfully — you can pull manually later.\n');
+    }
+  }
+
+  // ── Step 10: Plugin installation ────────────────────────────────────────────
+  write(output, '\nNext steps:\n');
+
+  if (presets.includes('claude')) {
+    const instructions =
+      'Run these commands inside Claude Code:\n' +
+      '  /plugin marketplace add imink/any-sync\n' +
+      '  /plugin install any-sync@any-sync-marketplace';
+    write(output, `\n  Claude Code plugin:\n    ${instructions.split('\n').join('\n    ')}\n`);
+    result.pluginInstructions.push({ tool: 'claude', instructions });
+  }
+
+  if (presets.includes('openclaw')) {
+    const instructions = 'Run: openclaw plugins install any-sync';
+    write(output, `\n  OpenClaw plugin:\n    ${instructions}\n`);
+    result.pluginInstructions.push({ tool: 'openclaw', instructions });
+  }
+
+  if (installVscode) {
+    if (tools.code) {
+      write(output, '\n  Installing VS Code extension...\n');
+      try {
+        execFileSync('code', ['--install-extension', 'patrickw1029.any-sync'], {
+          stdio: 'pipe',
+          encoding: 'utf8',
+        });
+        write(output, '    Any Sync extension installed successfully.\n');
+        result.pluginInstructions.push({ tool: 'vscode', installed: true });
+      } catch (err) {
+        write(output, `    Install failed: ${err.message}\n`);
+        write(output, '    Install manually: search "any-sync" in VS Code Extensions.\n');
+        result.pluginInstructions.push({ tool: 'vscode', installed: false });
+      }
+    } else {
+      write(output, '\n  VS Code not found. Install the extension manually:\n');
+      write(output, '    Search "any-sync" in VS Code Extensions, or run:\n');
+      write(output, '    code --install-extension patrickw1029.any-sync\n');
+      result.pluginInstructions.push({ tool: 'vscode', installed: false });
+    }
+  }
+
+  // ── Step 11: Summary ───────────────────────────────────────────────────────
+  write(output, '\n---\n');
+  write(output, 'Setup complete!\n');
+  write(output, `  Config:   ${configPath}\n`);
+  write(output, `  Repo:     ${repo} (branch: ${result.branch})\n`);
+  write(output, `  Presets:  ${presets.length > 0 ? presets.join(', ') : 'custom (edit config manually)'}\n`);
+  write(output, `  Mappings: ${result.mappingCount}\n`);
+  if (result.pullResult) {
+    const pulled = result.pullResult.pulled || [];
+    write(output, `  Pulled:   ${pulled.length} file(s)\n`);
+  }
+  write(output, '\n');
+
+  return result;
+}
+
+module.exports = { onboard, detectTools, mergePresetMappings };

package/lib/status.js

@@ -94,17 +94,27 @@ function status(configPath, lockfilePath) {
         }
       }
 
-      // Check for new files
+      // Check for new and untracked files
+      const untracked = [];
       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
+          // Apply exclude filter first — excluded files are never relevant
           if (m.exclude.length > 0 && matchesAny(m.exclude, relPath)) continue;
 
           const lockKey = makeKey(m.name, relPath);
-          if (!lf.getEntry(lockKey)) {
+          const isTracked = !!lf.getEntry(lockKey);
+
+          if (m.include.length > 0 && !matchesAny(m.include, relPath)) {
+            // File doesn't match include patterns — it's untracked (only if not already tracked)
+            if (!isTracked) {
+              untracked.push({ file: relPath });
+            }
+            continue;
+          }
+
+          // File matches filters — check if it's new
+          if (!isTracked) {
             changes.push({ file: relPath, type: 'new' });
           }
         }
@@ -117,6 +127,7 @@ function status(configPath, lockfilePath) {
         lastSync,
         trackedFiles,
         changes,
+        untracked,
       });
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@any-sync/cli",
-  "version": "0.2.0",
+  "version": "0.2.5",
   "description": "CLI and core library for Any Sync — bidirectional GitHub file sync",
   "main": "lib/index.js",
   "exports": {