node --version
# v20.x.x 以上を推奨

npm --version
# 10.x.x 以上

npm install -g @anthropic-ai/claude-code

mkdir file-organizer
cd file-organizer
claude

> Node.jsのCLIツールプロジェクトを初期化して。
  package.jsonのbinフィールドを設定して、
  グローバルインストールできるようにして。
  ツール名は "file-organizer"、コマンド名は "forg" にして

{
  "name": "file-organizer",
  "version": "1.0.0",
  "description": "ファイルを拡張子ごとにフォルダへ自動整理するCLIツール",
  "type": "module",
  "main": "src/index.js",
  "bin": {
    "forg": "./src/index.js"
  },
  "scripts": {
    "start": "node src/index.js",
    "dev": "node --watch src/index.js"
  },
  "keywords": ["cli", "file", "organizer", "directory"],
  "author": "",
  "license": "MIT",
  "engines": {
    "node": ">=18.0.0"
  }
}

> src/index.js を作成して。
  先頭にshebangを書いて、基本的なCLIの骨格を作って。
  コマンド名、バージョン、説明を表示するだけでOK

#!/usr/bin/env node

// file-organizer - ファイルを拡張子ごとに整理するCLIツール

const APP_NAME = 'file-organizer';
const VERSION = '1.0.0';

function main() {
  const args = process.argv.slice(2);

  if (args.includes('--version') || args.includes('-v')) {
    console.log(`${APP_NAME} v${VERSION}`);
    process.exit(0);
  }

  if (args.includes('--help') || args.includes('-h')) {
    console.log(`
${APP_NAME} v${VERSION}

使い方:
  forg [オプション] [ディレクトリ]

オプション:
  -v, --version  バージョンを表示
  -h, --help     ヘルプを表示
`);
    process.exit(0);
  }

  console.log(`${APP_NAME} v${VERSION} - ファイルオーガナイザー`);
  console.log('ファイルの整理を開始します...');
}

main();

> このCLIツールをローカルでテストする方法を教えて。
  npm link を使って

# プロジェクトルートで実行
npm link

# これで forg コマンドが使えるようになる
forg --version
# file-organizer v1.0.0

forg --help
# ヘルプメッセージが表示される

forg
# file-organizer v1.0.0 - ファイルオーガナイザー
# ファイルの整理を開始します...

node src/index.js --version
# file-organizer v1.0.0

> プロジェクトのディレクトリ構成を整理して。
  src/ 以下に commands/, utils/, config/ フォルダを作って、
  それぞれ空の index.js を置いて

file-organizer/
├── src/
│   ├── index.js          # エントリポイント（shebang付き）
│   ├── commands/          # サブコマンド（organize, undo, stats）
│   │   └── index.js
│   ├── utils/             # ユーティリティ関数
│   │   └── index.js
│   └── config/            # 設定管理
│       └── index.js
├── package.json
├── .gitignore
└── README.md

> Node.js用の.gitignoreを作成して

node_modules/
dist/
.env
*.log
.DS_Store

> commander.js をインストールして。
  ファイルオーガナイザーのCLI引数処理に使いたい

npm install commander

> src/index.js を Commander.js を使って書き換えて。
  以下のオプションを定義して:
  - 対象ディレクトリ（引数、省略時はカレントディレクトリ）
  - --dry-run: 実際に移動せず、何をするか表示するだけ
  - --verbose: 詳細ログを表示
  - --ext <extensions>: 対象の拡張子をカンマ区切りで指定
  - --output <dir>: 整理先のディレクトリを指定

#!/usr/bin/env node

import { Command } from 'commander';

const program = new Command();

program
  .name('forg')
  .description('ファイルを拡張子ごとにフォルダへ自動整理するCLIツール')
  .version('1.0.0', '-v, --version', 'バージョンを表示')
  .argument('[directory]', '整理するディレクトリ', '.')
  .option('-d, --dry-run', '実際に移動せず、実行計画を表示する', false)
  .option('--verbose', '詳細なログを表示する', false)
  .option('-e, --ext <extensions>', '対象の拡張子をカンマ区切りで指定', '')
  .option('-o, --output <dir>', '整理先のディレクトリを指定')
  .action((directory, options) => {
    console.log('対象ディレクトリ:', directory);
    console.log('オプション:', options);

    if (options.dryRun) {
      console.log('[DRY RUN] 実際のファイル移動は行いません');
    }

    if (options.ext) {
      const extensions = options.ext.split(',').map(e => e.trim());
      console.log('対象拡張子:', extensions);
    }

    console.log('ファイルの整理を開始します...');
  });

program.parse();

> --ext オプションの値をカンマ区切りで配列に変換する
  カスタムパーサーを追加して。
  さらに --max-size オプションを追加して、
  ファイルサイズの上限をMB単位で指定できるようにして。
  数値のバリデーションも入れて

// カスタムパーサー関数
function parseExtensions(value) {
  return value.split(',').map(ext => {
    ext = ext.trim().toLowerCase();
    return ext.startsWith('.') ? ext : `.${ext}`;
  });
}

function parseSize(value) {
  const size = parseFloat(value);
  if (isNaN(size) || size <= 0) {
    throw new Error('サイズは正の数値で指定してください');
  }
  return size;
}

program
  .option('-e, --ext <extensions>', '対象の拡張子をカンマ区切りで指定', parseExtensions)
  .option('--max-size <mb>', 'ファイルサイズの上限（MB）', parseSize);

Usage: forg [options] [directory]

ファイルを拡張子ごとにフォルダへ自動整理するCLIツール

Arguments:
  directory               整理するディレクトリ (default: ".")

Options:
  -v, --version           バージョンを表示
  -d, --dry-run           実際に移動せず、実行計画を表示する (default: false)
  --verbose               詳細なログを表示する (default: false)
  -e, --ext <extensions>  対象の拡張子をカンマ区切りで指定
  --max-size <mb>         ファイルサイズの上限（MB）
  -o, --output <dir>      整理先のディレクトリを指定
  -h, --help              ヘルプを表示

> ヘルプの末尾に使用例を追加して。
  forg ~/Downloads や forg --dry-run ~/Desktop のような例を表示したい

program
  .addHelpText('after', `
使用例:
  $ forg ~/Downloads              # ダウンロードフォルダを整理
  $ forg --dry-run ~/Desktop      # デスクトップの整理計画を表示
  $ forg -e jpg,png ~/Pictures    # 画像ファイルのみ整理
  $ forg -o ~/Sorted ~/Documents  # 整理先を指定して実行
`);

# バージョン表示
forg -v
# 1.0.0

# ヘルプ表示
forg --help

# ドライランモード
forg --dry-run ~/Downloads
# 対象ディレクトリ: /Users/you/Downloads
# オプション: { dryRun: true, verbose: false, ext: undefined, output: undefined }
# [DRY RUN] 実際のファイル移動は行いません

# 拡張子フィルター
forg -e jpg,png,gif ~/Pictures
# 対象拡張子: [ '.jpg', '.png', '.gif' ]

# 不正な値のバリデーション
forg --max-size abc
# error: option '--max-size <mb>' argument 'abc' is invalid.
# サイズは正の数値で指定してください

> src/utils/file-utils.js を作成して。
  fs/promises と path を使って、以下のヘルパー関数を実装して:
  - listFiles(dir): ディレクトリ内のファイル一覧を取得
  - getFileInfo(filePath): ファイルの情報（サイズ、拡張子、更新日）を取得
  - ensureDir(dir): ディレクトリが存在しなければ作成
  - moveFile(src, dest): ファイルを移動（同名ファイルがある場合はリネーム）

import { readdir, stat, mkdir, rename, access } from 'fs/promises';
import { join, extname, basename, dirname } from 'path';

/**
 * ディレクトリ内のファイル一覧を取得する（サブディレクトリは除外）
 */
export async function listFiles(dir) {
  const entries = await readdir(dir, { withFileTypes: true });
  return entries
    .filter(entry => entry.isFile())
    .map(entry => join(dir, entry.name));
}

/**
 * ファイルの詳細情報を取得する
 */
export async function getFileInfo(filePath) {
  const stats = await stat(filePath);
  return {
    path: filePath,
    name: basename(filePath),
    ext: extname(filePath).toLowerCase(),
    size: stats.size,
    modifiedAt: stats.mtime,
  };
}

/**
 * ディレクトリが存在しなければ再帰的に作成する
 */
export async function ensureDir(dir) {
  try {
    await access(dir);
  } catch {
    await mkdir(dir, { recursive: true });
  }
}

/**
 * ファイルを移動する（同名ファイルが存在する場合はリネーム）
 */
export async function moveFile(src, dest) {
  const destDir = dirname(dest);
  await ensureDir(destDir);

  let finalDest = dest;
  let counter = 1;

  while (true) {
    try {
      await access(finalDest);
      // ファイルが存在する場合、リネーム
      const ext = extname(dest);
      const nameWithoutExt = basename(dest, ext);
      finalDest = join(destDir, `${nameWithoutExt} (${counter})${ext}`);
      counter++;
    } catch {
      // ファイルが存在しない = この名前で移動OK
      break;
    }
  }

  await rename(src, finalDest);
  return finalDest;
}

> src/utils/categories.js を作成して。
  拡張子からファイルカテゴリへのマッピングを定義して。
  カテゴリは: 画像, 動画, 音声, ドキュメント, アーカイブ, コード, データ, その他

export const CATEGORY_MAP = {
  // 画像
  '.jpg': '画像',
  '.jpeg': '画像',
  '.png': '画像',
  '.gif': '画像',
  '.svg': '画像',
  '.webp': '画像',
  '.bmp': '画像',
  '.ico': '画像',

  // 動画
  '.mp4': '動画',
  '.avi': '動画',
  '.mov': '動画',
  '.mkv': '動画',
  '.webm': '動画',
  '.flv': '動画',

  // 音声
  '.mp3': '音声',
  '.wav': '音声',
  '.flac': '音声',
  '.aac': '音声',
  '.ogg': '音声',
  '.m4a': '音声',

  // ドキュメント
  '.pdf': 'ドキュメント',
  '.doc': 'ドキュメント',
  '.docx': 'ドキュメント',
  '.xls': 'ドキュメント',
  '.xlsx': 'ドキュメント',
  '.ppt': 'ドキュメント',
  '.pptx': 'ドキュメント',
  '.txt': 'ドキュメント',
  '.md': 'ドキュメント',
  '.csv': 'ドキュメント',

  // アーカイブ
  '.zip': 'アーカイブ',
  '.tar': 'アーカイブ',
  '.gz': 'アーカイブ',
  '.rar': 'アーカイブ',
  '.7z': 'アーカイブ',

  // コード
  '.js': 'コード',
  '.ts': 'コード',
  '.py': 'コード',
  '.html': 'コード',
  '.css': 'コード',
  '.json': 'コード',
  '.xml': 'コード',
  '.yaml': 'コード',
  '.yml': 'コード',

  // データ
  '.sql': 'データ',
  '.db': 'データ',
  '.sqlite': 'データ',
};

/**
 * 拡張子からカテゴリを判定する
 */
export function getCategory(ext) {
  return CATEGORY_MAP[ext.toLowerCase()] || 'その他';
}

/**
 * 全カテゴリ名の一覧を取得する
 */
export function getAllCategories() {
  const categories = new Set(Object.values(CATEGORY_MAP));
  categories.add('その他');
  return [...categories];
}

> src/commands/organize.js を作成して。
  listFiles, getFileInfo, moveFile, ensureDir と getCategory を使って、
  指定ディレクトリ内のファイルを拡張子のカテゴリ別フォルダに移動する
  organize コマンドを実装して。
  --dry-run オプションに対応して、
  --verbose で詳細ログを出すようにして

import { resolve } from 'path';
import { join } from 'path';
import { listFiles, getFileInfo, moveFile, ensureDir } from '../utils/file-utils.js';
import { getCategory } from '../utils/categories.js';

export async function organize(directory, options) {
  const targetDir = resolve(directory);
  const outputDir = options.output ? resolve(options.output) : targetDir;

  console.log(`\n対象ディレクトリ: ${targetDir}`);
  if (options.dryRun) {
    console.log('[DRY RUN] 実際のファイル移動は行いません\n');
  }

  // ファイル一覧を取得
  const files = await listFiles(targetDir);

  if (files.length === 0) {
    console.log('整理するファイルが見つかりませんでした。');
    return;
  }

  console.log(`${files.length} 個のファイルが見つかりました。\n`);

  // 拡張子フィルター
  const extFilter = options.ext
    ? new Set(options.ext)
    : null;

  const results = { moved: 0, skipped: 0, errors: 0 };

  for (const filePath of files) {
    const info = await getFileInfo(filePath);
    const category = getCategory(info.ext);

    // 拡張子フィルターが指定されている場合
    if (extFilter && !extFilter.has(info.ext)) {
      if (options.verbose) {
        console.log(`  スキップ: ${info.name} (フィルター外)`);
      }
      results.skipped++;
      continue;
    }

    const destDir = join(outputDir, category);
    const destPath = join(destDir, info.name);

    if (options.dryRun) {
      console.log(`  ${info.name} → ${category}/`);
      results.moved++;
      continue;
    }

    try {
      await ensureDir(destDir);
      const finalPath = await moveFile(filePath, destPath);
      results.moved++;

      if (options.verbose) {
        console.log(`  移動: ${info.name} → ${category}/`);
      }
    } catch (err) {
      console.error(`  エラー: ${info.name} - ${err.message}`);
      results.errors++;
    }
  }

  console.log(`\n完了: ${results.moved} 個移動, ${results.skipped} 個スキップ, ${results.errors} 個エラー`);
}

> src/index.js の action 内で organize 関数を呼び出すように修正して

#!/usr/bin/env node

import { Command } from 'commander';
import { organize } from './commands/organize.js';

const program = new Command();

program
  .name('forg')
  .description('ファイルを拡張子ごとにフォルダへ自動整理するCLIツール')
  .version('1.0.0')
  .argument('[directory]', '整理するディレクトリ', '.')
  .option('-d, --dry-run', '実際に移動せず、実行計画を表示する', false)
  .option('--verbose', '詳細なログを表示する', false)
  .option('-e, --ext <extensions>', '対象の拡張子をカンマ区切りで指定')
  .option('-o, --output <dir>', '整理先のディレクトリを指定')
  .action(async (directory, options) => {
    try {
      await organize(directory, options);
    } catch (err) {
      console.error(`エラーが発生しました: ${err.message}`);
      process.exit(1);
    }
  });

program.parse();

> @inquirer/prompts をインストールして。
  ユーザーへの確認や選択肢の表示に使いたい

npm install @inquirer/prompts

> src/commands/organize.js を修正して、
  ファイル一覧を表示した後に「実行しますか？」と
  confirmプロンプトを表示するようにして。
  --yes オプションで確認をスキップできるようにして。
  --dry-run の場合は確認不要にして

import { confirm } from '@inquirer/prompts';
import { resolve, join } from 'path';
import { listFiles, getFileInfo, moveFile, ensureDir } from '../utils/file-utils.js';
import { getCategory } from '../utils/categories.js';

export async function organize(directory, options) {
  const targetDir = resolve(directory);
  const outputDir = options.output ? resolve(options.output) : targetDir;

  // ファイル一覧を取得
  const files = await listFiles(targetDir);

  if (files.length === 0) {
    console.log('整理するファイルが見つかりませんでした。');
    return;
  }

  // ファイルをカテゴリ別に集計して表示
  const plan = await buildOrganizePlan(files, options);
  displayPlan(plan);

  // dry-run の場合はここで終了
  if (options.dryRun) {
    console.log('\n[DRY RUN] 以上が実行計画です。');
    return;
  }

  // --yes が指定されていない場合は確認を取る
  if (!options.yes) {
    const proceed = await confirm({
      message: `${plan.totalFiles} 個のファイルを移動しますか？`,
      default: false,
    });

    if (!proceed) {
      console.log('キャンセルしました。');
      return;
    }
  }

  // 実際のファイル移動を実行
  await executeOrganize(plan, options);
}

async function buildOrganizePlan(files, options) {
  const categories = {};
  let totalFiles = 0;

  for (const filePath of files) {
    const info = await getFileInfo(filePath);

    if (options.ext && !options.ext.includes(info.ext)) {
      continue;
    }

    const category = getCategory(info.ext);
    if (!categories[category]) {
      categories[category] = [];
    }
    categories[category].push(info);
    totalFiles++;
  }

  return { categories, totalFiles };
}

function displayPlan(plan) {
  console.log(`\n整理計画: ${plan.totalFiles} 個のファイル\n`);
  for (const [category, files] of Object.entries(plan.categories)) {
    console.log(`  ${category}/ (${files.length} 個)`);
    for (const file of files.slice(0, 3)) {
      console.log(`    - ${file.name}`);
    }
    if (files.length > 3) {
      console.log(`    ... 他 ${files.length - 3} 個`);
    }
  }
}

> 対話モード (--interactive) を追加して。
  checkboxプロンプトでカテゴリを選択できるようにして。
  選択したカテゴリのファイルだけを整理するようにして

import { confirm, checkbox } from '@inquirer/prompts';

async function selectCategories(plan) {
  const choices = Object.entries(plan.categories).map(([category, files]) => ({
    name: `${category} (${files.length} 個)`,
    value: category,
    checked: true,  // デフォルトで全選択
  }));

  const selected = await checkbox({
    message: '整理するカテゴリを選択してください',
    choices,
    required: true,
  });

  return selected;
}

> --interactive モード時に、出力先ディレクトリを
  inputプロンプトで入力できるようにして。
  デフォルト値は対象ディレクトリと同じにして。
  バリデーションで存在するパスかどうかチェックして

import { confirm, checkbox, input } from '@inquirer/prompts';
import { access } from 'fs/promises';

async function askOutputDir(defaultDir) {
  const outputDir = await input({
    message: '整理先のディレクトリを入力してください',
    default: defaultDir,
    validate: async (value) => {
      try {
        await access(resolve(value));
        return true;
      } catch {
        return 'ディレクトリが存在しません。作成しますか？ (パスを確認してください)';
      }
    },
  });

  return resolve(outputDir);
}

> organize コマンドに --interactive (-i) フラグを追加して、
  対話モードの完全なフローを実装して。
  カテゴリ選択 → 出力先入力 → 実行確認 の順で進むようにして

export async function organize(directory, options) {
  const targetDir = resolve(directory);
  const files = await listFiles(targetDir);

  if (files.length === 0) {
    console.log('整理するファイルが見つかりませんでした。');
    return;
  }

  const plan = await buildOrganizePlan(files, options);
  displayPlan(plan);

  if (options.dryRun) {
    console.log('\n[DRY RUN] 以上が実行計画です。');
    return;
  }

  let outputDir = options.output ? resolve(options.output) : targetDir;
  let selectedCategories = Object.keys(plan.categories);

  // 対話モード
  if (options.interactive) {
    selectedCategories = await selectCategories(plan);
    outputDir = await askOutputDir(outputDir);

    // 選択結果を表示
    console.log(`\n選択されたカテゴリ: ${selectedCategories.join(', ')}`);
    console.log(`出力先: ${outputDir}`);
  }

  // 最終確認
  if (!options.yes) {
    const fileCount = selectedCategories.reduce(
      (sum, cat) => sum + (plan.categories[cat]?.length || 0), 0
    );
    const proceed = await confirm({
      message: `${fileCount} 個のファイルを移動しますか？`,
      default: false,
    });

    if (!proceed) {
      console.log('キャンセルしました。');
      return;
    }
  }

  await executeOrganize(plan, options, selectedCategories, outputDir);
}

> chalk をインストールして。
  src/utils/logger.js を作成して、
  成功・警告・エラー・情報の各メッセージを
  色付きで表示するヘルパー関数を実装して

npm install chalk

import chalk from 'chalk';

export const logger = {
  success(message) {
    console.log(chalk.green('✓ ') + message);
  },

  warn(message) {
    console.log(chalk.yellow('⚠ ') + message);
  },

  error(message) {
    console.error(chalk.red('✗ ') + message);
  },

  info(message) {
    console.log(chalk.blue('ℹ ') + message);
  },

  dim(message) {
    console.log(chalk.dim(message));
  },

  highlight(message) {
    console.log(chalk.bold.cyan(message));
  },

  // ファイル移動のログ
  move(fileName, category) {
    const file = chalk.white(fileName);
    const arrow = chalk.dim('→');
    const dest = chalk.green.bold(category + '/');
    console.log(`  ${file} ${arrow} ${dest}`);
  },

  // セクションヘッダー
  header(title) {
    console.log();
    console.log(chalk.bold.underline(title));
    console.log();
  },
};

> ora をインストールして。
  ファイル整理の実行中にスピナーを表示するようにして。
  処理完了時に成功メッセージを表示して

npm install ora

import ora from 'ora';

async function executeOrganize(plan, options, selectedCategories, outputDir) {
  const spinner = ora({
    text: 'ファイルを整理しています...',
    color: 'cyan',
  }).start();

  const results = { moved: 0, skipped: 0, errors: 0 };

  for (const category of selectedCategories) {
    const files = plan.categories[category] || [];
    spinner.text = `${category} のファイルを移動中... (${results.moved}/${plan.totalFiles})`;

    for (const file of files) {
      try {
        const destDir = join(outputDir, category);
        const destPath = join(destDir, file.name);
        await ensureDir(destDir);
        await moveFile(file.path, destPath);
        results.moved++;
      } catch (err) {
        results.errors++;
        if (options.verbose) {
          spinner.stop();
          logger.error(`${file.name}: ${err.message}`);
          spinner.start();
        }
      }
    }
  }

  if (results.errors > 0) {
    spinner.warn(`完了（一部エラーあり）: ${results.moved} 個移動, ${results.errors} 個エラー`);
  } else {
    spinner.succeed(`完了: ${results.moved} 個のファイルを整理しました`);
  }

  return results;
}

> cli-table3 をインストールして。
  ファイル整理の結果をテーブル形式で表示する
  関数を作って。カテゴリ、ファイル数、合計サイズを列にして

npm install cli-table3

import Table from 'cli-table3';
import chalk from 'chalk';

export function displayResultsTable(plan) {
  const table = new Table({
    head: [
      chalk.cyan('カテゴリ'),
      chalk.cyan('ファイル数'),
      chalk.cyan('合計サイズ'),
    ],
    colWidths: [20, 15, 15],
    style: {
      head: [],
      border: ['dim'],
    },
  });

  let totalFiles = 0;
  let totalSize = 0;

  for (const [category, files] of Object.entries(plan.categories)) {
    const count = files.length;
    const size = files.reduce((sum, f) => sum + f.size, 0);
    totalFiles += count;
    totalSize += size;

    table.push([
      chalk.white(category),
      String(count),
      formatSize(size),
    ]);
  }

  // 合計行
  table.push([
    chalk.bold('合計'),
    chalk.bold(String(totalFiles)),
    chalk.bold(formatSize(totalSize)),
  ]);

  console.log(table.toString());
}

function formatSize(bytes) {
  if (bytes < 1024) return `${bytes} B`;
  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
}

┌──────────────────┬─────────────┬─────────────┐
│ カテゴリ          │ ファイル数    │ 合計サイズ    │
├──────────────────┼─────────────┼─────────────┤
│ 画像             │ 15          │ 24.3 MB     │
│ ドキュメント      │ 8           │ 5.1 MB      │
│ コード           │ 12          │ 156.2 KB    │
│ アーカイブ        │ 3           │ 120.5 MB    │
├──────────────────┼─────────────┼─────────────┤
│ 合計             │ 38          │ 150.1 MB    │
└──────────────────┴─────────────┴─────────────┘

> cli-progress をインストールして。
  ファイル数が20個以上の場合はプログレスバーを表示するようにして。
  20個未満の場合はスピナーのまま

npm install cli-progress

import cliProgress from 'cli-progress';
import chalk from 'chalk';

function createProgressBar(total) {
  return new cliProgress.SingleBar({
    format: chalk.cyan('{bar}') + ' | {percentage}% | {value}/{total} ファイル | {filename}',
    barCompleteChar: '█',
    barIncompleteChar: '░',
    hideCursor: true,
  });
}

// 使用例（executeOrganize 内）
if (plan.totalFiles >= 20) {
  const bar = createProgressBar(plan.totalFiles);
  bar.start(plan.totalFiles, 0, { filename: '' });

  for (const file of allFiles) {
    bar.update(results.moved + results.errors, { filename: file.name });
    // ... ファイル移動処理 ...
  }

  bar.stop();
}

████████████░░░░░░░░ | 60% | 24/40 ファイル | report.pdf

> forg CLIツールのサブコマンドを設計して。
  以下の3つのサブコマンドが必要:
  - organize: ファイルを整理する（既存機能）
  - undo: 直前の整理を元に戻す
  - stats: ディレクトリの統計情報を表示する
  サブコマンドなしで実行した場合はヘルプを表示して

> src/index.js を Commander.js のサブコマンドパターンで書き換えて。
  organize, undo, stats の3つのサブコマンドを定義して。
  各サブコマンドは別ファイル（src/commands/ 内）からインポートして

#!/usr/bin/env node

import { Command } from 'commander';
import { registerOrganizeCommand } from './commands/organize.js';
import { registerUndoCommand } from './commands/undo.js';
import { registerStatsCommand } from './commands/stats.js';

const program = new Command();

program
  .name('forg')
  .description('ファイルを拡張子ごとにフォルダへ自動整理するCLIツール')
  .version('1.0.0', '-v, --version');

// サブコマンドを登録
registerOrganizeCommand(program);
registerUndoCommand(program);
registerStatsCommand(program);

// サブコマンドなしで実行された場合はヘルプを表示
program.action(() => {
  program.help();
});

program.parse();

> src/commands/organize.js を修正して、
  registerOrganizeCommand 関数をエクスポートするようにして。
  program.command('organize') でサブコマンドを定義して。
  エイリアスとして 'org' も設定して

import { resolve, join } from 'path';
import { confirm, checkbox } from '@inquirer/prompts';
import ora from 'ora';
import { listFiles, getFileInfo, moveFile, ensureDir } from '../utils/file-utils.js';
import { getCategory } from '../utils/categories.js';
import { logger } from '../utils/logger.js';
import { saveHistory } from '../utils/history.js';

export function registerOrganizeCommand(program) {
  program
    .command('organize')
    .alias('org')
    .description('ファイルを拡張子のカテゴリ別フォルダに整理する')
    .argument('[directory]', '整理するディレクトリ', '.')
    .option('-d, --dry-run', '実行計画のみ表示', false)
    .option('--verbose', '詳細ログを表示', false)
    .option('-e, --ext <extensions>', '対象拡張子（カンマ区切り）')
    .option('-o, --output <dir>', '整理先ディレクトリ')
    .option('-y, --yes', '確認をスキップ', false)
    .option('-i, --interactive', '対話モード', false)
    .action(async (directory, options) => {
      try {
        await organize(directory, options);
      } catch (err) {
        logger.error(err.message);
        process.exit(1);
      }
    });
}

async function organize(directory, options) {
  // ... 既存の organize ロジック（前回までに実装済み）
}

> src/utils/history.js を作成して、
  ファイル移動の履歴を保存・読み込みする機能を実装して。
  履歴は .forg-history.json としてプロジェクトルートに保存して。
  その後 src/commands/undo.js を作成して、
  履歴を元にファイルを元の位置に戻す undo サブコマンドを実装して

// src/utils/history.js
import { readFile, writeFile } from 'fs/promises';
import { join } from 'path';

const HISTORY_FILE = '.forg-history.json';

export async function saveHistory(targetDir, moves) {
  const historyPath = join(targetDir, HISTORY_FILE);
  const entry = {
    timestamp: new Date().toISOString(),
    targetDir,
    moves: moves.map(m => ({
      from: m.originalPath,
      to: m.newPath,
    })),
  };

  let history = [];
  try {
    const data = await readFile(historyPath, 'utf-8');
    history = JSON.parse(data);
  } catch {
    // ファイルが存在しない場合は空配列
  }

  history.push(entry);
  await writeFile(historyPath, JSON.stringify(history, null, 2));
}

export async function loadHistory(targetDir) {
  const historyPath = join(targetDir, HISTORY_FILE);
  try {
    const data = await readFile(historyPath, 'utf-8');
    return JSON.parse(data);
  } catch {
    return [];
  }
}

export async function removeLastHistory(targetDir) {
  const historyPath = join(targetDir, HISTORY_FILE);
  const history = await loadHistory(targetDir);
  const last = history.pop();
  await writeFile(historyPath, JSON.stringify(history, null, 2));
  return last;
}

// src/commands/undo.js
import { resolve } from 'path';
import { confirm } from '@inquirer/prompts';
import ora from 'ora';
import { moveFile } from '../utils/file-utils.js';
import { loadHistory, removeLastHistory } from '../utils/history.js';
import { logger } from '../utils/logger.js';

export function registerUndoCommand(program) {
  program
    .command('undo')
    .description('直前のファイル整理を元に戻す')
    .argument('[directory]', '対象ディレクトリ', '.')
    .option('-y, --yes', '確認をスキップ', false)
    .action(async (directory, options) => {
      try {
        await undo(directory, options);
      } catch (err) {
        logger.error(err.message);
        process.exit(1);
      }
    });
}

async function undo(directory, options) {
  const targetDir = resolve(directory);
  const history = await loadHistory(targetDir);

  if (history.length === 0) {
    logger.warn('元に戻せる操作がありません。');
    return;
  }

  const lastEntry = history[history.length - 1];
  const date = new Date(lastEntry.timestamp).toLocaleString('ja-JP');

  logger.header('直前の操作');
  logger.info(`日時: ${date}`);
  logger.info(`ファイル数: ${lastEntry.moves.length}`);

  if (!options.yes) {
    const proceed = await confirm({
      message: `${lastEntry.moves.length} 個のファイルを元に戻しますか？`,
      default: false,
    });

    if (!proceed) {
      console.log('キャンセルしました。');
      return;
    }
  }

  const spinner = ora('ファイルを元に戻しています...').start();
  let restored = 0;

  for (const move of lastEntry.moves) {
    try {
      await moveFile(move.to, move.from);
      restored++;
    } catch (err) {
      logger.error(`復元失敗: ${move.to} - ${err.message}`);
    }
  }

  await removeLastHistory(targetDir);
  spinner.succeed(`${restored} 個のファイルを元に戻しました`);
}

> src/commands/stats.js を作成して。
  指定ディレクトリのファイル統計を表示するサブコマンドを実装して。
  カテゴリ別のファイル数、合計サイズをテーブルで表示して。
  上位5つの大きいファイルも表示して

// src/commands/stats.js
import { resolve } from 'path';
import { listFiles, getFileInfo } from '../utils/file-utils.js';
import { getCategory } from '../utils/categories.js';
import { displayResultsTable } from '../utils/display.js';
import { logger } from '../utils/logger.js';
import chalk from 'chalk';

export function registerStatsCommand(program) {
  program
    .command('stats')
    .description('ディレクトリのファイル統計情報を表示する')
    .argument('[directory]', '対象ディレクトリ', '.')
    .option('--top <n>', '大きいファイルの表示数', parseInt, 5)
    .action(async (directory, options) => {
      try {
        await stats(directory, options);
      } catch (err) {
        logger.error(err.message);
        process.exit(1);
      }
    });
}

async function stats(directory, options) {
  const targetDir = resolve(directory);
  const files = await listFiles(targetDir);

  if (files.length === 0) {
    logger.warn('ファイルが見つかりませんでした。');
    return;
  }

  const fileInfos = await Promise.all(files.map(getFileInfo));

  // カテゴリ別に集計
  const categories = {};
  for (const info of fileInfos) {
    const category = getCategory(info.ext);
    if (!categories[category]) {
      categories[category] = [];
    }
    categories[category].push(info);
  }

  logger.header(`ディレクトリ統計: ${targetDir}`);
  logger.info(`合計ファイル数: ${fileInfos.length}`);

  // テーブル表示
  displayResultsTable({ categories, totalFiles: fileInfos.length });

  // 上位N個の大きいファイル
  const topN = options.top;
  const sorted = fileInfos.sort((a, b) => b.size - a.size).slice(0, topN);

  console.log();
  logger.header(`サイズ上位 ${topN} ファイル`);
  for (const file of sorted) {
    const size = chalk.yellow(formatSize(file.size).padStart(10));
    console.log(`  ${size}  ${file.name}`);
  }
}

> src/config/config-manager.js を作成して。
  OSに応じた設定ファイルの場所を自動判定して、
  ~/.config/forg/config.json に設定を保存・読み込みする
  ConfigManager クラスを実装して。
  デフォルト設定との統合も行って

import { readFile, writeFile, mkdir } from 'fs/promises';
import { join } from 'path';
import { homedir, platform } from 'os';

const APP_NAME = 'forg';

// デフォルト設定
const DEFAULT_CONFIG = {
  defaultDir: '.',
  outputDir: null,
  verbose: false,
  dryRun: false,
  interactive: false,
  confirmBeforeMove: true,
  categories: {
    // カスタムカテゴリマッピング（ユーザーが拡張可能）
  },
  ignore: [
    '.DS_Store',
    'Thumbs.db',
    '.gitkeep',
  ],
  maxFileSizeMB: null,
};

export class ConfigManager {
  constructor() {
    this.configDir = this._getConfigDir();
    this.configPath = join(this.configDir, 'config.json');
    this.config = null;
  }

  /**
   * OSに応じた設定ディレクトリのパスを返す
   */
  _getConfigDir() {
    const os = platform();

    if (os === 'win32') {
      const appData = process.env.APPDATA || join(homedir(), 'AppData', 'Roaming');
      return join(appData, APP_NAME);
    }

    // macOS / Linux: XDG Base Directory 仕様
    const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
    return join(xdgConfig, APP_NAME);
  }

  /**
   * 設定を読み込む（存在しなければデフォルト値を使用）
   */
  async load() {
    try {
      const data = await readFile(this.configPath, 'utf-8');
      const userConfig = JSON.parse(data);
      // デフォルト設定とユーザー設定をマージ
      this.config = this._deepMerge(DEFAULT_CONFIG, userConfig);
    } catch {
      this.config = { ...DEFAULT_CONFIG };
    }
    return this.config;
  }

  /**
   * 設定を保存する
   */
  async save(config) {
    await mkdir(this.configDir, { recursive: true });
    const data = JSON.stringify(config || this.config, null, 2);
    await writeFile(this.configPath, data, 'utf-8');
  }

  /**
   * 特定のキーの値を取得する
   */
  get(key) {
    if (!this.config) {
      throw new Error('設定が読み込まれていません。load() を先に呼んでください。');
    }
    return key.split('.').reduce((obj, k) => obj?.[k], this.config);
  }

  /**
   * 特定のキーに値を設定する
   */
  set(key, value) {
    if (!this.config) {
      this.config = { ...DEFAULT_CONFIG };
    }

    const keys = key.split('.');
    let obj = this.config;
    for (let i = 0; i < keys.length - 1; i++) {
      if (!obj[keys[i]] || typeof obj[keys[i]] !== 'object') {
        obj[keys[i]] = {};
      }
      obj = obj[keys[i]];
    }
    obj[keys[keys.length - 1]] = value;
  }

  /**
   * 設定をデフォルトにリセットする
   */
  async reset() {
    this.config = { ...DEFAULT_CONFIG };
    await this.save();
  }

  /**
   * オブジェクトのディープマージ
   */
  _deepMerge(target, source) {
    const result = { ...target };
    for (const key of Object.keys(source)) {
      if (
        source[key] &&
        typeof source[key] === 'object' &&
        !Array.isArray(source[key]) &&
        target[key] &&
        typeof target[key] === 'object'
      ) {
        result[key] = this._deepMerge(target[key], source[key]);
      } else {
        result[key] = source[key];
      }
    }
    return result;
  }
}

> src/commands/config.js を作成して。
  以下のサブコマンドを実装して:
  - forg config list: 全設定を表示
  - forg config get <key>: 特定の設定値を表示
  - forg config set <key> <value>: 設定値を変更
  - forg config reset: デフォルトに戻す
  - forg config path: 設定ファイルのパスを表示

import { ConfigManager } from '../config/config-manager.js';
import { logger } from '../utils/logger.js';
import { confirm } from '@inquirer/prompts';
import chalk from 'chalk';

export function registerConfigCommand(program) {
  const configCmd = program
    .command('config')
    .description('ツールの設定を管理する');

  // forg config list
  configCmd
    .command('list')
    .alias('ls')
    .description('現在の設定を一覧表示する')
    .action(async () => {
      const cm = new ConfigManager();
      const config = await cm.load();

      logger.header('現在の設定');
      printConfig(config);
      console.log();
      logger.dim(`設定ファイル: ${cm.configPath}`);
    });

  // forg config get <key>
  configCmd
    .command('get <key>')
    .description('指定したキーの設定値を表示する')
    .action(async (key) => {
      const cm = new ConfigManager();
      await cm.load();
      const value = cm.get(key);

      if (value === undefined) {
        logger.warn(`キー "${key}" は存在しません`);
        process.exit(1);
      }

      if (typeof value === 'object') {
        console.log(JSON.stringify(value, null, 2));
      } else {
        console.log(value);
      }
    });

  // forg config set <key> <value>
  configCmd
    .command('set <key> <value>')
    .description('指定したキーに値を設定する')
    .action(async (key, value) => {
      const cm = new ConfigManager();
      await cm.load();

      // 値の型変換
      let parsedValue = value;
      if (value === 'true') parsedValue = true;
      else if (value === 'false') parsedValue = false;
      else if (value === 'null') parsedValue = null;
      else if (!isNaN(Number(value))) parsedValue = Number(value);

      cm.set(key, parsedValue);
      await cm.save();

      logger.success(`${key} = ${JSON.stringify(parsedValue)}`);
    });

  // forg config reset
  configCmd
    .command('reset')
    .description('設定をデフォルトに戻す')
    .action(async () => {
      const proceed = await confirm({
        message: '設定をデフォルトに戻しますか？',
        default: false,
      });

      if (!proceed) {
        console.log('キャンセルしました。');
        return;
      }

      const cm = new ConfigManager();
      await cm.reset();
      logger.success('設定をデフォルトに戻しました');
    });

  // forg config path
  configCmd
    .command('path')
    .description('設定ファイルのパスを表示する')
    .action(() => {
      const cm = new ConfigManager();
      console.log(cm.configPath);
    });
}

function printConfig(config, prefix = '') {
  for (const [key, value] of Object.entries(config)) {
    const fullKey = prefix ? `${prefix}.${key}` : key;
    if (value && typeof value === 'object' && !Array.isArray(value)) {
      printConfig(value, fullKey);
    } else {
      const keyStr = chalk.cyan(fullKey.padEnd(25));
      const valueStr = chalk.white(JSON.stringify(value));
      console.log(`  ${keyStr} ${valueStr}`);
    }
  }
}

# 全設定を表示
forg config list

# 特定の設定値を確認
forg config get verbose
# false

# 設定を変更
forg config set verbose true
# ✓ verbose = true

forg config set ignore '["*.tmp",".DS_Store"]'

# 設定ファイルの場所を確認
forg config path
# /home/user/.config/forg/config.json

# デフォルトに戻す
forg config reset

> organize コマンドで、設定ファイルの値を
  コマンドラインオプションのデフォルト値として使うようにして。
  コマンドラインで明示的に指定された場合はそちらを優先して

// src/commands/organize.js（修正部分）
import { ConfigManager } from '../config/config-manager.js';

export function registerOrganizeCommand(program) {
  program
    .command('organize')
    .alias('org')
    .description('ファイルを拡張子のカテゴリ別フォルダに整理する')
    .argument('[directory]', '整理するディレクトリ')
    .option('-d, --dry-run', '実行計画のみ表示')
    .option('--verbose', '詳細ログを表示')
    .option('-o, --output <dir>', '整理先ディレクトリ')
    .option('-y, --yes', '確認をスキップ')
    .action(async (directory, cmdOptions) => {
      try {
        // 設定ファイルを読み込み
        const cm = new ConfigManager();
        const config = await cm.load();

        // 優先順位: コマンドラインオプション > 設定ファイル > デフォルト値
        const options = {
          dryRun: cmdOptions.dryRun ?? config.dryRun ?? false,
          verbose: cmdOptions.verbose ?? config.verbose ?? false,
          output: cmdOptions.output ?? config.outputDir ?? null,
          yes: cmdOptions.yes ?? !config.confirmBeforeMove,
          interactive: cmdOptions.interactive ?? config.interactive ?? false,
        };

        const targetDir = directory ?? config.defaultDir ?? '.';

        await organize(targetDir, options);
      } catch (err) {
        logger.error(err.message);
        process.exit(1);
      }
    });
}

> 設定ファイルの categories フィールドに
  ユーザー独自の拡張子マッピングを追加できるようにして。
  デフォルトのカテゴリマッピングとマージして使うようにして

// src/utils/categories.js（修正版）
import { CATEGORY_MAP } from './default-categories.js';

export function getCategory(ext, customCategories = {}) {
  // カスタムカテゴリを優先
  if (customCategories[ext]) {
    return customCategories[ext];
  }
  return CATEGORY_MAP[ext.toLowerCase()] || 'その他';
}

{
  "categories": {
    ".psd": "デザイン",
    ".ai": "デザイン",
    ".sketch": "デザイン",
    ".fig": "デザイン",
    ".blend": "3Dモデル",
    ".obj": "3Dモデル",
    ".fbx": "3Dモデル"
  }
}