@our2ndbrain/cli 1.1.3

package/bin/2ndbrain.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * 2ndBrain CLI
+ * 
+ * A CLI tool for managing 2ndBrain projects.
+ */
+
+const { program } = require('commander');
+const { init, update, remove, member, completion } = require('../src');
+const pkg = require('../package.json');
+
+// ANSI color codes for terminal output
+const colors = {
+  green: (str) => `\x1b[32m${str}\x1b[0m`,
+  yellow: (str) => `\x1b[33m${str}\x1b[0m`,
+  red: (str) => `\x1b[31m${str}\x1b[0m`,
+};
+
+// Logger utility
+const log = {
+  info: (msg) => console.log(msg),
+  success: (msg) => console.log(colors.green(msg)),
+  warn: (msg) => console.log(colors.yellow(msg)),
+  error: (msg) => console.log(colors.red(msg)),
+};
+
+// CLI setup
+program
+  .name('2ndbrain')
+  .description('CLI tool for 2ndBrain - A personal knowledge management system')
+  .version(pkg.version);
+
+// Init command
+program
+  .command('init [path]')
+  .description('Initialize a new 2ndBrain project (or integrate into existing vault)')
+  .option('-t, --template <path>', 'Use custom template directory')
+  .option('-f, --force', 'Force overwrite existing 2ndBrain project')
+  .option('--reset-obsidian, --reset-obs', 'Reset .obsidian directory from template (overwrites all settings)')
+  .action(async (targetPath = '.', options) => {
+    try {
+      await init(targetPath, options, log);
+    } catch (err) {
+      log.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+// Update command
+program
+  .command('update [path]')
+  .description('Update framework files from template')
+  .option('-t, --template <path>', 'Use custom template directory')
+  .option('-d, --dry-run', 'Show what would be updated without making changes')
+  .option('-y, --yes', 'Auto-confirm all updates without prompting')
+  .action(async (targetPath = '.', options) => {
+    try {
+      await update(targetPath, options, log);
+    } catch (err) {
+      log.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+// Remove command
+program
+  .command('remove [path]')
+  .description('Remove framework files (preserves user data)')
+  .option('-d, --dry-run', 'Show what would be removed without making changes')
+  .option('-f, --force', 'Force removal without confirmation')
+  .action(async (targetPath = '.', options) => {
+    try {
+      await remove(targetPath, options, log);
+    } catch (err) {
+      log.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+// Member command
+program
+  .command('member <name> [path]')
+  .description('Initialize a new member directory with personal dashboard')
+  .option('-f, --force', 'Force overwrite existing member directory')
+  .option('--no-config', 'Skip Obsidian daily-notes.json config update')
+  .action(async (name, targetPath = '.', options) => {
+    try {
+      await member(name, targetPath, options, log);
+    } catch (err) {
+      log.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+// Completion command
+program
+  .command('completion <shell>')
+  .description('Generate shell completion script (bash, zsh, fish)')
+  .action((shell) => {
+    const script = completion(shell);
+    if (script) {
+      // Ignore EPIPE errors (when pipe is closed early, e.g., piped to head)
+      process.stdout.on('error', (err) => {
+        if (err.code === 'EPIPE') {
+          process.exit(0);
+        }
+        throw err;
+      });
+      process.stdout.write(script);
+    } else {
+      log.error(`Unsupported shell: ${shell}. Use bash, zsh, or fish.`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@our2ndbrain/cli",
+    "version": "1.1.3",
+    "description": "CLI tool for 2ndBrain - A personal knowledge management system based on PARA + C-O-R-D + Append-and-Review",
+    "keywords": [
+        "2ndbrain",
+        "knowledge-management",
+        "obsidian",
+        "para",
+        "gtd",
+        "productivity"
+    ],
+    "author": "Our2ndBrain",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Our2ndBrain/2ndBrain-Template.git"
+    },
+    "homepage": "https://github.com/Our2ndBrain/2ndBrain-Template",
+    "bin": {
+        "2ndbrain": "bin/2ndbrain.js"
+    },
+    "main": "./src/index.js",
+    "files": [
+        "bin/",
+        "src/",
+        ".obsidian/",
+        "00_Dashboard/",
+        "10_Inbox/Agents/",
+        "99_System/",
+        "AGENTS.md",
+        "CHANGELOG.md",
+        "CLAUDE.md",
+        "LICENSE",
+        "README.md"
+    ],
+    "bugs": {
+        "url": "https://github.com/Our2ndBrain/2ndBrain-Template/issues"
+    },
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "scripts": {
+        "version": "node scripts/version.js && git add CHANGELOG.md",
+        "postversion": "git push && git push --tags && npm publish"
+    },
+    "dependencies": {
+        "chalk": "^4.1.2",
+        "commander": "^12.0.0",
+        "diff": "^5.2.0",
+        "fs-extra": "^11.2.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/src/commands/completion.js

@@ -0,0 +1,198 @@
+/**
+ * 2ndBrain CLI - Completion Command
+ * 
+ * Generate shell completion scripts (kubectl style)
+ */
+
+const BASH_COMPLETION = `# 2ndbrain bash completion
+#
+# Installation:
+#
+#   ## Load completion into current shell
+#   source <(2ndbrain completion bash)
+#
+#   ## Or write to file and source from .bash_profile (recommended for macOS)
+#   2ndbrain completion bash > ~/.2ndbrain-completion.bash
+#   echo 'source ~/.2ndbrain-completion.bash' >> ~/.bash_profile
+#   source ~/.bash_profile
+#
+# Note: On macOS with bash 3.x, "source <(...)" may not work.
+# Use the file-based method instead, or install bash 4+ via Homebrew.
+
+_2ndbrain_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  local cmd="\${COMP_WORDS[1]}"
+
+  # Top-level commands
+  local commands="init update remove member completion"
+
+  case "\$cmd" in
+    init)
+      case "\$prev" in
+        -t|--template)
+          COMPREPLY=( $(compgen -d -- "\$cur") )
+          return 0
+          ;;
+      esac
+      COMPREPLY=( $(compgen -W "-t --template -f --force -h --help" -- "\$cur") )
+      [[ -z "\$cur" || "\$cur" != -* ]] && COMPREPLY+=( $(compgen -d -- "\$cur") )
+      ;;
+    update)
+      case "\$prev" in
+        -t|--template)
+          COMPREPLY=( $(compgen -d -- "\$cur") )
+          return 0
+          ;;
+      esac
+      COMPREPLY=( $(compgen -W "-t --template -d --dry-run -h --help" -- "\$cur") )
+      [[ -z "\$cur" || "\$cur" != -* ]] && COMPREPLY+=( $(compgen -d -- "\$cur") )
+      ;;
+    remove)
+      COMPREPLY=( $(compgen -W "-d --dry-run -f --force -h --help" -- "\$cur") )
+      [[ -z "\$cur" || "\$cur" != -* ]] && COMPREPLY+=( $(compgen -d -- "\$cur") )
+      ;;
+    member)
+      COMPREPLY=( $(compgen -W "-f --force --no-config -h --help" -- "\$cur") )
+      ;;
+    completion)
+      COMPREPLY=( $(compgen -W "bash zsh fish" -- "\$cur") )
+      ;;
+    *)
+      COMPREPLY=( $(compgen -W "\$commands -V --version -h --help" -- "\$cur") )
+      ;;
+  esac
+}
+
+complete -F _2ndbrain_completions 2ndbrain
+`;
+
+const ZSH_COMPLETION = `#compdef 2ndbrain
+
+# 2ndbrain zsh completion
+
+_2ndbrain() {
+  local -a commands
+  commands=(
+    'init:Initialize a new 2ndBrain project'
+    'update:Update framework files from template'
+    'remove:Remove framework files (preserves user data)'
+    'member:Initialize a new member directory'
+    'completion:Generate shell completion script'
+  )
+
+  _arguments -C \\
+    '(-V --version)'{-V,--version}'[Show version]' \\
+    '(-h --help)'{-h,--help}'[Show help]' \\
+    '1: :->command' \\
+    '*:: :->args'
+
+  case \$state in
+    command)
+      _describe -t commands 'commands' commands
+      ;;
+    args)
+      case \$words[1] in
+        init)
+          _arguments \\
+            '(-t --template)'{-t,--template}'[Use custom template directory]:directory:_directories' \\
+            '(-f --force)'{-f,--force}'[Force overwrite existing project]' \\
+            '(-h --help)'{-h,--help}'[Show help]' \\
+            '1:path:_directories'
+          ;;
+        update)
+          _arguments \\
+            '(-t --template)'{-t,--template}'[Use custom template directory]:directory:_directories' \\
+            '(-d --dry-run)'{-d,--dry-run}'[Show what would be updated]' \\
+            '(-h --help)'{-h,--help}'[Show help]' \\
+            '1:path:_directories'
+          ;;
+        remove)
+          _arguments \\
+            '(-d --dry-run)'{-d,--dry-run}'[Show what would be removed]' \\
+            '(-f --force)'{-f,--force}'[Force removal without confirmation]' \\
+            '(-h --help)'{-h,--help}'[Show help]' \\
+            '1:path:_directories'
+          ;;
+        member)
+          _arguments \\
+            '(-f --force)'{-f,--force}'[Force overwrite existing member]' \\
+            '--no-config[Skip Obsidian config update]' \\
+            '(-h --help)'{-h,--help}'[Show help]' \\
+            '1:name:' \\
+            '2:path:_directories'
+          ;;
+        completion)
+          _arguments \\
+            '1:shell:(bash zsh fish)'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_2ndbrain
+`;
+
+const FISH_COMPLETION = `# 2ndbrain fish completion
+
+# Disable file completion by default
+complete -c 2ndbrain -f
+
+# Top-level commands
+complete -c 2ndbrain -n '__fish_use_subcommand' -a 'init' -d 'Initialize a new 2ndBrain project'
+complete -c 2ndbrain -n '__fish_use_subcommand' -a 'update' -d 'Update framework files from template'
+complete -c 2ndbrain -n '__fish_use_subcommand' -a 'remove' -d 'Remove framework files'
+complete -c 2ndbrain -n '__fish_use_subcommand' -a 'member' -d 'Initialize a new member directory'
+complete -c 2ndbrain -n '__fish_use_subcommand' -a 'completion' -d 'Generate shell completion script'
+
+# Global options
+complete -c 2ndbrain -n '__fish_use_subcommand' -s V -l version -d 'Show version'
+complete -c 2ndbrain -n '__fish_use_subcommand' -s h -l help -d 'Show help'
+
+# init options
+complete -c 2ndbrain -n '__fish_seen_subcommand_from init' -s t -l template -d 'Use custom template directory' -r -a '(__fish_complete_directories)'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from init' -s f -l force -d 'Force overwrite existing project'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from init' -s h -l help -d 'Show help'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from init' -a '(__fish_complete_directories)'
+
+# update options
+complete -c 2ndbrain -n '__fish_seen_subcommand_from update' -s t -l template -d 'Use custom template directory' -r -a '(__fish_complete_directories)'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from update' -s d -l dry-run -d 'Show what would be updated'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from update' -s h -l help -d 'Show help'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from update' -a '(__fish_complete_directories)'
+
+# remove options
+complete -c 2ndbrain -n '__fish_seen_subcommand_from remove' -s d -l dry-run -d 'Show what would be removed'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from remove' -s f -l force -d 'Force removal without confirmation'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from remove' -s h -l help -d 'Show help'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from remove' -a '(__fish_complete_directories)'
+
+# member options
+complete -c 2ndbrain -n '__fish_seen_subcommand_from member' -s f -l force -d 'Force overwrite existing member'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from member' -l no-config -d 'Skip Obsidian config update'
+complete -c 2ndbrain -n '__fish_seen_subcommand_from member' -s h -l help -d 'Show help'
+
+# completion options
+complete -c 2ndbrain -n '__fish_seen_subcommand_from completion' -a 'bash zsh fish'
+`;
+
+/**
+ * Generate shell completion script
+ * @param {string} shell - Shell type: bash, zsh, or fish
+ * @returns {string|null} Completion script or null if unsupported
+ */
+function completion(shell) {
+  switch (shell) {
+    case 'bash':
+      return BASH_COMPLETION;
+    case 'zsh':
+      return ZSH_COMPLETION;
+    case 'fish':
+      return FISH_COMPLETION;
+    default:
+      return null;
+  }
+}
+
+module.exports = completion;

package/src/commands/init.js

@@ -0,0 +1,308 @@
+/**
+ * 2ndBrain CLI - Init Command
+ *
+ * Initialize a new 2ndBrain project or integrate into existing vault.
+ */
+
+const path = require('path');
+const fs = require('fs-extra');
+const {
+  TEMPLATE_ROOT,
+  FRAMEWORK_FILES,
+  FRAMEWORK_DIRS,
+  USER_DATA_DIRS,
+  COPY_DIRS,
+  SMART_COPY_DIRS,
+  INIT_ONLY_FILES,
+  is2ndBrainProject,
+} = require('../lib/config');
+const { copyFiles, ensureDirs, createFile, isDirEmpty, copyFilesSmart } = require('../lib/files');
+const { copyObsidianDirSmart } = require('../lib/obsidian');
+
+/**
+ * Scan existing directory to understand current state
+ * @param {string} targetPath - Target directory path
+ * @returns {Promise<Object>} Scan result with existing files/dirs
+ */
+async function scanExistingDirectory(targetPath) {
+  const scan = {
+    hasFiles: false,
+    existingDirs: new Set(),
+    existingFiles: new Set(),
+    hasObsidian: false,
+    hasUserDataDirs: new Set(),
+    hasFrameworkDirs: new Set(),
+  };
+
+  if (!await fs.pathExists(targetPath)) {
+    return scan;
+  }
+
+  const entries = await fs.readdir(targetPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      scan.existingDirs.add(entry.name);
+      scan.hasFiles = true;
+
+      if (entry.name === '.obsidian') {
+        scan.hasObsidian = true;
+      }
+      if (USER_DATA_DIRS.includes(entry.name)) {
+        scan.hasUserDataDirs.add(entry.name);
+      }
+      if (FRAMEWORK_DIRS.some(d => d.startsWith(entry.name))) {
+        scan.hasFrameworkDirs.add(entry.name);
+      }
+    } else if (entry.isFile()) {
+      scan.existingFiles.add(entry.name);
+      scan.hasFiles = true;
+    }
+  }
+
+  return scan;
+}
+
+/**
+ * Handle .obsidian directory reset from template
+ * @param {string} obsidianSrc - Template .obsidian path
+ * @param {string} obsidianDest - Target .obsidian path
+ * @param {Function} log - Logger function
+ * @param {boolean} skipConfirmation - Skip confirmation if true
+ * @returns {Promise<boolean>} True if reset performed, false if cancelled
+ */
+async function handleObsidianReset(obsidianSrc, obsidianDest, log, skipConfirmation = false) {
+  const { confirm } = require('../lib/prompt');
+
+  // Check if template exists
+  if (!await fs.pathExists(obsidianSrc)) {
+    log.warn('  Template .obsidian not found, skipping reset');
+    return false;
+  }
+
+  const targetExists = await fs.pathExists(obsidianDest);
+
+  // If target doesn't exist, just copy (no confirmation needed)
+  if (!targetExists) {
+    log.info('  No existing .obsidian found, creating from template...');
+    await fs.copy(obsidianSrc, obsidianDest);
+    log.success('  + .obsidian/');
+    return true;
+  }
+
+  // Target exists - require confirmation
+  log.warn('');
+  log.warn('╔════════════════════════════════════════════════════════════╗');
+  log.warn('║          ⚠️  OBSIDIAN CONFIGURATION RESET WARNING         ║');
+  log.warn('╚════════════════════════════════════════════════════════════╝');
+  log.warn('');
+  log.warn('You are about to COMPLETELY REPLACE your .obsidian directory.');
+  log.warn('This will delete all your Obsidian settings and preferences.');
+  log.warn('');
+
+  if (skipConfirmation) {
+    log.warn('  Force reset: skipping confirmation (--force)');
+  }
+
+  const confirmed = skipConfirmation || await confirm(
+    'Are you sure you want to reset your .obsidian directory?',
+    false // Default to NO for safety
+  );
+
+  if (!confirmed) {
+    log.info('');
+    log.info('Obsidian reset cancelled. Preserving existing configuration.');
+    return false;
+  }
+
+  // Perform the reset
+  try {
+    log.info('  Resetting .obsidian directory...');
+    await fs.remove(obsidianDest);
+    await fs.copy(obsidianSrc, obsidianDest);
+    log.success('  .obsidian/ reset complete');
+    log.info('    • All settings replaced with template defaults');
+    return true;
+  } catch (err) {
+    log.error(`  Failed to reset .obsidian: ${err.message}`);
+    throw err;
+  }
+}
+
+/**
+ * Initialize a new 2ndBrain project or integrate into existing vault
+ * @param {string} targetPath - Target directory path
+ * @param {Object} options - Command options
+ * @param {string} [options.template] - Custom template path
+ * @param {boolean} [options.force] - Force overwrite existing 2ndBrain project
+ * @param {boolean} [options.resetObsidian] - Reset .obsidian from template
+ * @param {Function} log - Logger function
+ */
+async function init(targetPath, options, log) {
+  const resolvedPath = path.resolve(targetPath);
+  const templateRoot = options.template ? path.resolve(options.template) : TEMPLATE_ROOT;
+
+  log.info(`Initializing 2ndBrain project at: ${resolvedPath}`);
+  log.info(`Using template from: ${templateRoot}`);
+
+  // Check if target directory exists and scan it
+  const dirExists = await fs.pathExists(resolvedPath);
+  const isEmpty = dirExists && await isDirEmpty(resolvedPath);
+  const isExistingProject = dirExists && is2ndBrainProject(resolvedPath);
+
+  // Handle existing 2ndBrain project
+  if (isExistingProject) {
+    if (!options.force) {
+      log.warn('This directory is already a 2ndBrain project.');
+      log.info('Use "2ndbrain update" to update framework files.');
+      log.info('Or use --force to reinitialize (this will overwrite framework files).');
+      throw new Error('Target directory is already a 2ndBrain project');
+    }
+    log.warn('Reinitializing existing 2ndBrain project (--force)...');
+  }
+
+  // Create target directory if needed
+  await fs.ensureDir(resolvedPath);
+
+  // Scan existing directory for smart integration
+  const scan = await scanExistingDirectory(resolvedPath);
+  const isIntegrateMode = !isEmpty && scan.hasFiles && !isExistingProject;
+
+  if (isIntegrateMode) {
+    log.info('');
+    log.info('Integration mode: Merging 2ndBrain framework into existing vault');
+    if (scan.hasUserDataDirs.size > 0) {
+      log.info(`Found existing user data: ${[...scan.hasUserDataDirs].join(', ')}`);
+    }
+    if (scan.hasFrameworkDirs.size > 0) {
+      log.warn(`Found existing framework dirs: ${[...scan.hasFrameworkDirs].join(', ')}`);
+    }
+    log.info('');
+  }
+
+  // Step 1: Create framework directories (only missing ones)
+  log.info('Ensuring directories exist...');
+  const dirsToCreate = [];
+
+  for (const dir of FRAMEWORK_DIRS) {
+    const dirPath = path.join(resolvedPath, dir);
+    if (!await fs.pathExists(dirPath)) {
+      dirsToCreate.push(dir);
+    }
+  }
+
+  // Create missing framework directories
+  if (dirsToCreate.length > 0) {
+    await ensureDirs(dirsToCreate, resolvedPath);
+    dirsToCreate.forEach(dir => log.success(`  + ${dir}/`));
+  } else {
+    log.info('  All framework directories exist');
+  }
+
+  // Ensure user data directories exist (never overwrite)
+  const userDataDirsToCreate = [];
+  for (const dir of USER_DATA_DIRS) {
+    const dirPath = path.join(resolvedPath, dir);
+    if (!await fs.pathExists(dirPath)) {
+      userDataDirsToCreate.push(dir);
+    }
+  }
+
+  if (userDataDirsToCreate.length > 0) {
+    await ensureDirs(userDataDirsToCreate, resolvedPath);
+    userDataDirsToCreate.forEach(dir => log.success(`  + ${dir}/ (user data)`));
+  }
+
+  // Step 2: Copy framework files (skip existing)
+  log.info('Copying framework files...');
+  const fileResult = await copyFilesSmart(
+    FRAMEWORK_FILES,
+    templateRoot,
+    resolvedPath,
+    {},
+    (file, action, detail) => {
+      if (action === 'copy') {
+        log.success(`  + ${file}`);
+      } else if (action === 'unchanged') {
+        log.info(`  = ${file} (exists, unchanged)`);
+      } else if (action === 'error') {
+        log.error(`  ! ${file} (error: ${detail})`);
+      }
+    }
+  );
+
+  // Step 3: Process .obsidian directory
+  log.info('Processing .obsidian configuration...');
+  const obsidianSrc = path.join(templateRoot, '.obsidian');
+  const obsidianDest = path.join(resolvedPath, '.obsidian');
+
+  if (await fs.pathExists(obsidianSrc)) {
+    // Handle --reset-obsidian option
+    if (options.resetObsidian) {
+      await handleObsidianReset(obsidianSrc, obsidianDest, log, options.force);
+    } else if (await fs.pathExists(obsidianDest)) {
+      // Smart merge existing .obsidian
+      log.info('  Merging .obsidian/ (preserving your settings)...');
+      const obsidianResult = await copyObsidianDirSmart(
+        obsidianSrc,
+        obsidianDest,
+        {
+          onProgress: (file, action, detail) => {
+            if (action === 'added') {
+              log.success(`    + ${file}`);
+            } else if (action === 'merged') {
+              log.success(`    * ${file} (merged)`);
+              if (detail.added && detail.added.length > 0) {
+                log.info(`      plugins added: ${detail.added.join(', ')}`);
+              }
+            } else if (action === 'preserved') {
+              log.info(`    = ${file} (preserved)`);
+            }
+          },
+        }
+      );
+      log.success(`  .obsidian/ merged: ${obsidianResult.added.length + obsidianResult.merged.length} updated`);
+    } else {
+      // New .obsidian directory
+      await fs.copy(obsidianSrc, obsidianDest);
+      log.success(`  + .obsidian/`);
+    }
+  }
+
+  // Step 4: Create init-only files (if missing)
+  log.info('Creating initial files...');
+  for (const { path: filePath, content } of INIT_ONLY_FILES) {
+    const fullPath = path.join(resolvedPath, filePath);
+    if (!await fs.pathExists(fullPath)) {
+      await createFile(fullPath, content);
+      log.success(`  + ${filePath}`);
+    }
+  }
+
+  // Step 5: Create .gitkeep files for user data directories
+  for (const dir of USER_DATA_DIRS) {
+    const gitkeepPath = path.join(resolvedPath, dir, '.gitkeep');
+    if (!await fs.pathExists(gitkeepPath)) {
+      await createFile(gitkeepPath, '');
+    }
+  }
+
+  // Summary
+  log.info('');
+  log.success(isIntegrateMode ? '2ndBrain framework integrated!' : '2ndBrain project initialized!');
+  log.info(`  Created: ${fileResult.copied.length} files`);
+  if (fileResult.unchanged.length > 0) {
+    log.info(`  Skipped: ${fileResult.unchanged.length} existing files`);
+  }
+  if (fileResult.errors.length > 0) {
+    log.error(`  Errors: ${fileResult.errors.length} files`);
+  }
+
+  log.info('');
+  log.info('Next steps:');
+  log.info('  1. Open this directory with Obsidian');
+  log.info('  2. Run: ./99_System/Scripts/init_member.sh <your-name>');
+  log.info('  3. Start recording your first task!');
+}
+
+module.exports = init;