syui/claude
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add

Browse Source
This commit is contained in:
syui
2025-07-05 13:48:50 +09:00
parent 00c9af330b
commit 9758126225
26 changed files with 3134 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
.claude/commands/help.md Normal file
View File

@ -0,0 +1,66 @@
---
name: help
description: Claude Code拡張ヘルプ - ショートカットと便利な機能
---
# 🤖 Claude Code 拡張ヘルプ
## 📝 テキスト入力ショートカット
### 基本移動
- `^A (Ctrl+A)` - 行頭に移動
- `^E (Ctrl+E)` - 行末に移動
- `^B (Ctrl+B)` - 1文字前に戻る
- `^F (Ctrl+F)` - 1文字後に進む
- `Alt+B` - 1単語前に移動
- `Alt+F` - 1単語後に移動
### 削除・編集
- `^W (Ctrl+W)` - 単語単位で削除（高速）
- `^K (Ctrl+K)` - カーソル位置から行末まで削除
- `^U (Ctrl+U)` - カーソル位置から行頭まで削除
- `^D (Ctrl+D)` - カーソル位置の文字を削除
- `^Y (Ctrl+Y)` - 最後に削除したテキストを貼り付け
### 履歴・検索
- `^R (Ctrl+R)` - インクリメンタル履歴検索
- `↑/↓` - コマンド履歴のナビゲーション
## 🎮 Claude Code特有の操作
- `ESC×1` - 入力中のテキストを全消去
- `ESC×2` - 前のメッセージに戻る
- `\ + Enter` - 複数行入力（すべての環境で動作）
- `Tab` - オートコンプリート
## 🚀 便利な起動オプション
```bash
claude --resume # 前回のセッションを復元
claude --dangerously-skip-permissions # 許可確認をスキップ（危険）
claude --thinking # 思考プロセスを表示
claude IMAGE.png # 画像を含めて起動
```
## 💭 思考モード
- `think` - 標準的な思考モード
- `think hard` - より深い思考モード
- `ultrathink` - 最も深い思考モード
## 📚 公式ドキュメント
- [概要](https://docs.anthropic.com/en/docs/claude-code/overview)
- [クイックスタート](https://docs.anthropic.com/en/docs/claude-code/quickstart)
- [インタラクティブモード](https://docs.anthropic.com/en/docs/claude-code/interactive-mode)
- [設定](https://docs.anthropic.com/en/docs/claude-code/settings)
- [スラッシュコマンド](https://docs.anthropic.com/en/docs/claude-code/slash-commands)
## 💡 Tips
- 画像はクリップボードから直接ペースト可能
- `#`で始まるメッセージはCLAUDE.mdに追加される
- `~/.claude/settings.json`で詳細設定が可能
- `~/.claude/CLAUDE.md`でグローバル設定を記述
詳細なヘルプは `/project:help/[カテゴリ]` で確認できます。

60
.claude/commands/help/quickref.md Normal file
View File

@ -0,0 +1,60 @@
---
name: quickref
description: クイックリファレンス - よく使う機能の一覧
bash: echo "📋 Claude Code クイックリファレンス"
---
## 🚀 最もよく使う機能
### 必須ショートカット
```
^A/^E 行頭/行末に移動
^W 単語削除（高速）
^J 改行（Enter代替）
ESC×1 入力を全消去
ESC×2 前のメッセージに戻る
\ + Enter 複数行入力
```
### 起動オプション
```bash
claude --resume # セッション復元
claude --dangerously-skip-permissions # 許可スキップ
claude --thinking # 思考プロセス表示
```
### 思考モード
```
think # 標準思考
think hard # 深い思考
ultrathink # 最深思考
```
### スラッシュコマンド
```
/help ヘルプ表示
/clear 会話クリア
/init CLAUDE.md生成
/web Web検索有効化
/exit 終了
```
## 🔥 便利な小技
1. **画像ペースト**: クリップボードから直接貼り付け可能
2. **メモリ追加**: `#`で始まるメッセージはCLAUDE.mdに自動追加
3. **ファイル参照**: `@ファイル名`でファイル内容を含める
## 📝 設定ファイル
- `~/.claude/settings.json` - グローバル設定
- `~/.claude/CLAUDE.md` - グローバル指示
- `./CLAUDE.md` - プロジェクト固有の指示
## 🔗 重要なリンク
- [公式ドキュメント](https://docs.anthropic.com/en/docs/claude-code)
- [GitHub Issues](https://github.com/anthropics/claude-code/issues)
---
💡 詳細は `/project:help` で確認

121
.claude/commands/help/safety.md Normal file
View File

@ -0,0 +1,121 @@
---
name: safety
description: 安全にClaude Codeを使うためのガイド
---
# 🛡️ Claude Code 安全利用ガイド
## ⚠️ 基本的な安全対策
### 1. バックアップ
```bash
# Gitでバージョン管理
git add . && git commit -m "Before Claude Code session"
# 重要ファイルのバックアップ
cp important-file.conf important-file.conf.backup
```
### 2. 危険なコマンドの回避
絶対に使わないコマンド:
- `rm -rf /` または `rm -rf ~`
- `dd if=/dev/zero of=/dev/sda`
- `:(){ :|:& };:` (Fork bomb)
- `chmod -R 777 /`
### 3. 権限の制限
```bash
# 専用ユーザーで実行
sudo -u claude-user claude
# Dockerコンテナ内で実行
docker run -it --rm -v $(pwd):/workspace ubuntu
```
## 🔧 Hooks による保護
`~/.claude/settings.json`:
```json
{
"hooks": {
"before_bash": "~/.claude/hooks/safety-check.sh"
}
}
```
安全チェックスクリプトの例:
```bash
#!/bin/bash
if [[ "$1" =~ (rm -rf|dd if=|mkfs) ]]; then
echo "危険なコマンドをブロックしました"
exit 1
fi
```
## 🐳 Docker サンドボックス
### 基本的な使用方法
```bash
# Dockerコンテナで隔離環境を作成
docker run -it --rm \
-v $(pwd):/workspace:ro \
--memory="2g" \
--cpus="1.5" \
ubuntu:latest
```
### docker-compose を使用
```yaml
version: '3.8'
services:
claude-sandbox:
image: ubuntu:latest
volumes:
- .:/workspace
mem_limit: 2g
cpus: 1.5
read_only: true
```
## 📋 チェックリスト
作業前の確認事項:
- [ ] 重要ファイルのバックアップ完了
- [ ] Gitでコミット済み
- [ ] 実行環境の確認（本番環境でないこと）
- [ ] 危険なコマンドのチェック
- [ ] 必要に応じてDockerやVMを使用
## 🚨 緊急時の対応
1. **即座に停止**: `Ctrl+C`
2. **プロセスの確認**: `ps aux | grep claude`
3. **強制終了**: `kill -9 <PID>`
4. **復元**: Gitやバックアップから復元
## 💡 推奨事項
1. **段階的な実行**
- まず `--dry-run` で確認
- 小さな変更から始める
- 影響範囲を限定
2. **監視とログ**
- `script` コマンドでセッションを記録
- 重要な操作は履歴に残す
3. **CLAUDE.mdに安全ルールを記載**
```markdown
## 安全ルール
- システムファイルの変更禁止
- rm -rf の使用禁止
- sudo使用時は必ず確認
```
## 🔗 関連リソース
- [Arch Linux安全ガイド](/project:help/archlinux-safety)
- [公式セキュリティドキュメント](https://docs.anthropic.com/en/docs/claude-code/security)
---
⚡ 安全第一で効率的な開発を！

88
.claude/commands/help/shortcuts.md Normal file
View File

@ -0,0 +1,88 @@
---
name: shortcuts
description: キーボードショートカット詳細ガイド
---
# ⌨️ キーボードショートカット完全ガイド
## 基本的なテキスト編集
### カーソル移動
| ショートカット | 動作 | 説明 |
|--------------|------|------|
| `Ctrl+A` | 行頭へ移動 | カーソルを現在の行の先頭に移動 |
| `Ctrl+E` | 行末へ移動 | カーソルを現在の行の末尾に移動 |
| `Ctrl+B` | 1文字左へ | カーソルを1文字分左に移動 |
| `Ctrl+F` | 1文字右へ | カーソルを1文字分右に移動 |
### 単語単位の移動
| ショートカット | 動作 | 説明 |
|--------------|------|------|
| `Alt+B` | 前の単語へ | カーソルを前の単語の先頭に移動 |
| `Alt+F` | 次の単語へ | カーソルを次の単語の末尾に移動 |
### 削除操作
| ショートカット | 動作 | 説明 |
|--------------|------|------|
| `Ctrl+W` | 単語削除 | カーソル位置から前の単語を削除 |
| `Ctrl+K` | 行末まで削除 | カーソル位置から行末までを削除 |
| `Ctrl+U` | 行頭まで削除 | カーソル位置から行頭までを削除 |
| `Ctrl+D` | 文字削除 | カーソル位置の文字を削除 |
| `Backspace` | 前の文字削除 | カーソルの前の文字を削除 |
### 特殊操作
| ショートカット | 動作 | 説明 |
|--------------|------|------|
| `Ctrl+Y` | ヤンク | 最後に削除したテキストを貼り付け |
| `Ctrl+T` | 文字入れ替え | カーソル位置の文字と前の文字を入れ替え |
## Claude Code特有のショートカット
### 入力制御
| 操作 | 動作 | 使用場面 |
|------|------|---------|
| `ESC` 1回 | 入力クリア | 現在入力中のテキストをすべて削除 |
| `ESC` 2回 | メッセージ履歴 | 前のメッセージに戻る |
| `\ + Enter` | 改行 | 複数行入力時の改行（確実に動作） |
| `Shift+Enter` | 改行 | 一部の環境で利用可能 |
| `Option+Enter` | 改行 | macOSのデフォルト |
### 履歴操作
| ショートカット | 動作 | 説明 |
|--------------|------|------|
| `↑` | 前の履歴 | コマンド履歴を遡る |
| `↓` | 次の履歴 | コマンド履歴を進む |
| `Ctrl+R` | 履歴検索 | インクリメンタル検索開始 |
| `Ctrl+G` | 検索キャンセル | 履歴検索を中止 |
## Vimモード（有効な場合）
### モード切り替え
- `i` - 挿入モードへ
- `ESC` - ノーマルモードへ
- `v` - ビジュアルモードへ
### ノーマルモードでの移動
- `h/j/k/l` - 左/下/上/右
- `w/b` - 単語単位で前/後
- `0/$` - 行頭/行末
- `gg/G` - ファイル先頭/末尾
## 💡 効率的な使い方のコツ
1. **高速削除**: `Ctrl+W`は`Backspace`連打より効率的
2. **行編集**: `Ctrl+A`→`Ctrl+K`で行全体をクリア
3. **履歴活用**: `Ctrl+R`で過去のコマンドを素早く検索
4. **複数行入力**: 確実に改行したい場合は`\`+`Enter`を使用
## 🔧 トラブルシューティング
### ショートカットが効かない場合
1. ターミナルエミュレータの設定を確認
2. 入力メソッドが干渉していないか確認
3. tmux/screenを使用している場合はプレフィックスキーを確認
### 環境別の注意点
- **macOS**: `Option`キーの動作はターミナル設定に依存
- **Linux**: ディストリビューションによって挙動が異なる場合あり
- **Windows**: WSL2使用時は Windows Terminal の設定も確認

8
.claude/settings.local.json Normal file
View File

@ -0,0 +1,8 @@
{
"permissions": {
"allow": [
"Bash(chmod:*)"
],
"deny": []
}
}

142
CLAUDE.md Normal file
View File

@ -0,0 +1,142 @@
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## プロジェクトの目的
このリポジトリは、Claude Codeを効果的に使うための方法論と環境整備を探求するプロジェクトです。
特に、zsh/tmux/vim環境での統合、他のAIとの連携、MCP（Model Context Protocol）の活用に焦点を当てています。
## 主要機能
### 1. 拡張ヘルプシステム
- `/user:help` - カスタムヘルプ表示
- `/user:help/shortcuts` - キーボードショートカット詳細
- `/user:help/quickref` - クイックリファレンス
- `/user:help/safety` - 安全利用ガイド
### 2. AI統合機能
- `ai-import <file>` - ChatGPT会話のインポート
- `ai-compare <task>` - 複数AIでの比較検証
- `ai-chain <prompt>` - AIチェーン実行
- `ai-tmux` - AI作業用tmuxセッション
### 3. MCP（Model Context Protocol）
- ファイルシステム、GitHub、Docker等との統合
- カスタムMCPサーバーの実装
- Arch Linux / macOS固有のツール連携
### 4. ターミナル統合
- zsh拡張コマンド群
- tmux専用キーバインド
- vim統合機能
## 重要な参考資料
- `docs/advanced-setup.md` - 高度な設定ガイド
- `docs/guides/custom-commands.md` - カスタムコマンドの作成方法
- `docs/guides/archlinux-safety.md` - Arch Linux安全ガイド
- `docs/guides/custom-help-setup.md` - ヘルプシステムの設定
## セットアップ
### クイックセットアップ
```bash
# 全機能の一括設定
./setup-advanced.sh all
# 個別設定
./setup-advanced.sh zsh # zsh統合
./setup-advanced.sh tmux # tmux統合
./setup-advanced.sh mcp # MCP設定
./setup-advanced.sh ai # AI統合
```
### 手動セットアップ
```bash
# zsh設定の読み込み
source ./shell-config/.zshrc_claude
# カスタムヘルプのインストール
cp -r .claude/commands/* ~/.claude/commands/
# MCP設定
./mcp/setup-mcp.sh all
```
## 使用可能なコマンド
### Claude Code拡張コマンド
- `claude-analyze <file>` - ファイル解析
- `claude-review <file>` - コードレビュー
- `claude-test <file>` - テスト生成
- `claude-refactor <file>` - リファクタリング
- `claude-docs` - ドキュメント生成
- `claude-status` - 現在の作業状況を共有
- `claude-env` - 環境情報の共有
### AI統合コマンド
- `ai-import <chatgpt_log>` - ChatGPTログのインポート
- `ai-compare <task>` - 複数AIでの比較
- `ai-chain <prompt>` - AIチェーン実行
- `ai-tmux` - 専用tmuxセッション起動
### MCP関連コマンド
- `mcp-setup install` - MCPサーバーインストール
- `mcp-setup config` - 設定ファイル作成
- `mcp-setup test` - 動作テスト
## 開発方針
1. **コンテキストの継承**
- 過去の会話ログを参考に、一貫した開発アプローチを維持
- ChatGPTで培った知見をClaude Codeに引き継ぐ
2. **効果的なプロンプト戦略**
- 明確で具体的な指示
- 段階的なタスク分解
- 適切なコンテキストの提供
3. **安全性の確保**
- 危険なコマンドの実行前チェック
- Docker/VM環境での隔離実行
- 自動バックアップとスナップショット
## ディレクトリ構造
```
claude/
├── CLAUDE.md # このファイル
├── setup-advanced.sh # 一括セットアップスクリプト
├── .claude/ # Claude Code設定
│ └── commands/ # カスタムコマンド
├── docs/ # ドキュメント
│ ├── guides/ # 各種ガイド
│ └── advanced-setup.md # 高度な設定ガイド
├── scripts/ # ユーティリティスクリプト
│ ├── ai-integration.sh # AI統合機能
│ ├── claude-help.sh # 拡張ヘルプ
│ └── *-safety-check.sh # 安全チェック
├── mcp/ # MCP設定
│ └── setup-mcp.sh # MCPセットアップ
├── shell-config/ # シェル設定
│ └── .zshrc_claude # zsh拡張設定
└── docker/ # Docker環境
└── archlinux/ # Arch Linux環境
```
## 対象環境
- **OS**: Arch Linux, macOS
- **シェル**: zsh
- **ターミナル**: tmux統合
- **エディタ**: vim/neovim統合
- **AI**: Claude Code + ChatGPT等の連携
## 注意事項
1. **セキュリティ**: 本番環境では安全チェック機能を有効化
2. **パフォーマンス**: 大規模なプロジェクトではDocker環境を推奨
3. **互換性**: 一部の機能はzsh/tmux特有の機能に依存
このリポジトリは、Claude Codeを中心とした現代的な開発環境の構築を目指しています。

26
docker/Dockerfile Normal file
View File

@ -0,0 +1,26 @@
FROM ubuntu:22.04
# 基本的なツールをインストール
RUN apt-get update && apt-get install -y \
curl \
git \
python3 \
nodejs \
npm \
sudo \
&& rm -rf /var/lib/apt/lists/*
# 非rootユーザーを作成
RUN useradd -m -s /bin/bash claude-user && \
echo 'claude-user ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
# 作業ディレクトリを設定
WORKDIR /workspace
# ユーザーを切り替え
USER claude-user
# Claude Codeをインストール（実際のインストールコマンドに置き換え）
# RUN curl -fsSL https://... | sh
CMD ["/bin/bash"]

30
docker/archlinux/.dockerignore Normal file
View File

@ -0,0 +1,30 @@
# Git
.git
.gitignore
# Documentation
*.md
docs/
# Temporary files
*.tmp
*.temp
*.log
# Cache
.cache/
__pycache__/
*.pyc
# IDE
.vscode/
.idea/
# Node.js
node_modules/
npm-debug.log*
# Build artifacts
build/
dist/
target/

56
docker/archlinux/Dockerfile Normal file
View File

@ -0,0 +1,56 @@
FROM archlinux:latest
# ミラーリストを更新して高速化
RUN pacman -Sy --noconfirm reflector && \
reflector --country Japan --latest 5 --sort rate --save /etc/pacman.d/mirrorlist
# システム更新と基本パッケージのインストール
RUN pacman -Syu --noconfirm && \
pacman -S --noconfirm \
base-devel \
git \
vim \
neovim \
nodejs \
npm \
python \
python-pip \
go \
rust \
docker \
wget \
curl \
jq \
ripgrep \
fd \
bat \
exa \
zsh \
openssh \
sudo \
&& pacman -Scc --noconfirm
# 非rootユーザーを作成（wheel グループに追加）
RUN useradd -m -G wheel -s /bin/zsh claude && \
echo 'claude ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers
# AURヘルパー (yay) をインストール
USER claude
WORKDIR /home/claude
RUN git clone https://aur.archlinux.org/yay.git && \
cd yay && \
makepkg -si --noconfirm && \
cd .. && \
rm -rf yay
# 作業ディレクトリの設定
WORKDIR /workspace
# 必要に応じてClaude Codeをインストール
# RUN curl -fsSL https://... | sh
# デフォルトシェルをzshに
SHELL ["/bin/zsh", "-c"]
# コンテナ起動時のコマンド
CMD ["/bin/zsh"]

115
docker/archlinux/README.md Normal file
View File

@ -0,0 +1,115 @@
# Claude Code Arch Linux Docker環境
安全なClaude Code実行環境をArch LinuxベースのDockerコンテナで提供します。
## クイックスタート
```bash
# イメージのビルド
./run.sh build
# コンテナの起動
./run.sh start
# シェルに接続
./run.sh shell
```
## 機能
- **最新のArch Linux**ベース
- **非rootユーザー** (claude) での実行
- **開発ツール**プリインストール
- Node.js, Python, Go, Rust
- Git, Neovim, ripgrep, fd
- yay (AURヘルパー)
- **リソース制限**設定済み
- **ボリューム永続化**
- pacmanキャッシュ
- yayキャッシュ
## セキュリティ機能
- 非特権コンテナ
- リソース制限 (CPU: 2コア, メモリ: 4GB上限)
- ネットワーク分離
- 読み取り専用オプション対応
## 使い方
### 基本コマンド
```bash
# ビルド
./run.sh build
# 起動
./run.sh start
# 接続
./run.sh shell
# 停止
./run.sh stop
# 完全削除
./run.sh clean
```
### Docker Compose直接使用
```bash
# バックグラウンドで起動
docker-compose up -d
# ログ確認
docker-compose logs -f
# コンテナに入る
docker-compose exec -u claude claude-arch /bin/zsh
# 停止
docker-compose down
```
## カスタマイズ
### より厳格なセキュリティ
`docker-compose.yml`で以下のコメントを解除：
```yaml
read_only: true
tmpfs:
- /tmp
- /run
- /home/claude/.cache
```
### Docker in Docker
Dockerソケットのマウントを有効化：
```yaml
volumes:
- /var/run/docker.sock:/var/run/docker.sock
```
## トラブルシューティング
### pacmanエラー
```bash
# コンテナ内で実行
sudo pacman -Sy archlinux-keyring
sudo pacman-key --refresh-keys
```
### 権限エラー
ホストのファイルの所有者を確認：
```bash
# UID/GIDの確認
docker-compose exec claude-arch id
```

104
docker/archlinux/docker-compose.yml Normal file
View File

@ -0,0 +1,104 @@
version: '3.8'
services:
claude-arch:
build:
context: .
dockerfile: Dockerfile
image: claude-archlinux:latest
container_name: claude-arch-sandbox
hostname: claude-arch
# ボリュームマウント
volumes:
# プロジェクトディレクトリをマウント
- ../../:/workspace:rw
# ホームディレクトリの設定ファイルを共有（オプション）
- ~/.config/nvim:/home/claude/.config/nvim:ro
- ~/.zshrc:/home/claude/.zshrc:ro
# Dockerソケット（Docker in Dockerを使う場合）
# - /var/run/docker.sock:/var/run/docker.sock
# pacmanキャッシュを永続化（ダウンロード時間短縮）
- pacman-cache:/var/cache/pacman/pkg
# yayキャッシュを永続化
- yay-cache:/home/claude/.cache/yay
# 環境変数
environment:
- LANG=ja_JP.UTF-8
- TZ=Asia/Tokyo
- TERM=xterm-256color
# Claude Code用の環境変数
- CLAUDE_SAFE_MODE=true
- CLAUDE_CONTAINER=true
# リソース制限
deploy:
resources:
limits:
cpus: '2'
memory: 4G
reservations:
cpus: '1'
memory: 2G
# セキュリティオプション
security_opt:
- no-new-privileges:true
# AppArmorプロファイル（利用可能な場合）
# - apparmor:docker-default
# ネットワーク設定
networks:
- claude-net
# 対話型シェルの有効化
stdin_open: true
tty: true
# 読み取り専用ルートファイルシステム（より安全だが制限的）
# read_only: true
# tmpfs:
# - /tmp
# - /run
# - /home/claude/.cache
# ユーザー指定
user: claude
# ヘルスチェック
healthcheck:
test: ["CMD", "echo", "healthy"]
interval: 30s
timeout: 3s
retries: 3
# 開発用データベース（必要に応じて）
# postgres:
# image: postgres:15-alpine
# container_name: claude-postgres
# environment:
# POSTGRES_DB: dev
# POSTGRES_USER: claude
# POSTGRES_PASSWORD: claude-dev-pass
# volumes:
# - postgres-data:/var/lib/postgresql/data
# networks:
# - claude-net
# ボリューム定義
volumes:
pacman-cache:
driver: local
yay-cache:
driver: local
# postgres-data:
# driver: local
# ネットワーク定義
networks:
claude-net:
driver: bridge
ipam:
config:
- subnet: 172.25.0.0/24

94
docker/archlinux/run.sh Executable file
View File

@ -0,0 +1,94 @@
#!/bin/bash
# Claude Code Arch Linux Docker環境の起動スクリプト
set -e
# カラー出力の定義
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m' # No Color
# 使用方法の表示
usage() {
echo "使用方法: $0 [オプション]"
echo "オプション:"
echo " build - Dockerイメージをビルド"
echo " start - コンテナを起動"
echo " stop - コンテナを停止"
echo " shell - コンテナ内でシェルを起動"
echo " clean - コンテナとボリュームを削除"
echo " logs - コンテナのログを表示"
exit 1
}
# Dockerイメージのビルド
build() {
echo -e "${GREEN}Arch Linux Dockerイメージをビルドしています...${NC}"
docker-compose build --no-cache
echo -e "${GREEN}ビルド完了！${NC}"
}
# コンテナの起動
start() {
echo -e "${GREEN}コンテナを起動しています...${NC}"
docker-compose up -d
echo -e "${GREEN}起動完了！${NC}"
echo -e "${YELLOW}シェルに接続するには: $0 shell${NC}"
}
# コンテナの停止
stop() {
echo -e "${YELLOW}コンテナを停止しています...${NC}"
docker-compose down
echo -e "${GREEN}停止完了！${NC}"
}
# シェルへの接続
shell() {
echo -e "${GREEN}Arch Linuxコンテナに接続しています...${NC}"
docker-compose exec -u claude claude-arch /bin/zsh
}
# クリーンアップ
clean() {
echo -e "${RED}警告: この操作はコンテナとボリュームを削除します！${NC}"
read -p "続行しますか？ (y/N): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
docker-compose down -v
echo -e "${GREEN}クリーンアップ完了！${NC}"
else
echo -e "${YELLOW}キャンセルしました${NC}"
fi
}
# ログの表示
logs() {
docker-compose logs -f claude-arch
}
# メイン処理
case "$1" in
build)
build
;;
start)
start
;;
stop)
stop
;;
shell)
shell
;;
clean)
clean
;;
logs)
logs
;;
*)
usage
;;
esac

222
docs/advanced-setup.md Normal file
View File

@ -0,0 +1,222 @@
# Claude Code Advanced Setup Guide
## 🔧 Terminal環境との統合
### tmux統合
```bash
# .tmux.conf に追加
bind-key c command-prompt -p "claude prompt:" "new-window 'claude \"%1\"'"
bind-key C send-keys "claude " C-m
# Claude Code専用のtmuxセッション
alias claude-session='tmux new-session -s claude -d "claude --resume" \; attach'
```
### Vim/Neovim統合
```vim
" .vimrc または init.vim
" Claude Codeに現在のファイルを送る
nnoremap <leader>cc :!claude "このコードをレビューして: $(cat %)"<CR>
nnoremap <leader>ce :!claude "このエラーを解決して: $(cat %)"<CR>
" 選択範囲をClaude Codeに送る
vnoremap <leader>cs :w !claude "この部分を説明して"<CR>
```
## 🤖 AI連携パターン
### 1. ChatGPT → Claude Code パイプライン
```bash
# ChatGPTの会話ログをClaude Codeに渡す
function ai-handoff() {
local chatgpt_log="$1"
claude "以下のChatGPTとの会話を踏まえて、実装を進めてください: $(cat $chatgpt_log)"
}
# 使用例
ai-handoff ~/chatgpt-logs/feature-design.md
```
### 2. 複数AIの比較検証
```bash
# 同じプロンプトを複数のAIに送る
function ai-compare() {
local prompt="$1"
echo "=== Claude Code ===" > ai-comparison.md
claude "$prompt" >> ai-comparison.md
echo -e "\n=== ChatGPT ===" >> ai-comparison.md
# ChatGPT CLIがある場合
# chatgpt "$prompt" >> ai-comparison.md
}
```
## 🔌 MCP (Model Context Protocol) 活用
### 基本的なMCPツール設定
```json
// ~/.claude/claude_desktop_config.json
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem"],
"env": {
"FILESYSTEM_ROOT": "/home/user/projects"
}
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "your-token"
}
},
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"DATABASE_URL": "postgresql://localhost/mydb"
}
}
}
}
```
### カスタムMCPサーバー例
```python
# custom-mcp-server.py
import asyncio
from mcp.server import Server
from mcp.types import Tool, TextContent
app = Server("custom-tools")
@app.tool()
async def search_codebase(query: str) -> TextContent:
"""コードベース全体を検索"""
result = await asyncio.create_subprocess_exec(
"rg", query, "--json",
stdout=asyncio.subprocess.PIPE
)
stdout, _ = await result.communicate()
return TextContent(text=stdout.decode())
if __name__ == "__main__":
app.run()
```
## 🚀 実践的なワークフロー
### 1. ドキュメント駆動開発
```bash
# ChatGPTで設計 → Claude Codeで実装
function design-to-code() {
local design_doc="$1"
# 設計ドキュメントをCLAUDE.mdに追加
echo "## 設計仕様" >> CLAUDE.md
cat "$design_doc" >> CLAUDE.md
# Claude Codeセッション開始
claude "この設計に基づいて実装を開始してください"
}
```
### 2. エラー解決フロー
```bash
# エラーログを自動的にClaude Codeに送る
function debug-with-claude() {
local error_log="/tmp/last-error.log"
# エラーをキャプチャ
"$@" 2> "$error_log"
if [ $? -ne 0 ]; then
claude "このエラーを解決してください: $(cat $error_log)"
fi
}
# 使用例
debug-with-claude npm test
```
### 3. コードレビュー自動化
```bash
# Git pre-commit hook
#!/bin/bash
# .git/hooks/pre-commit
changed_files=$(git diff --cached --name-only)
if [ -n "$changed_files" ]; then
echo "$changed_files" | xargs cat | \
claude "これらの変更をレビューして、問題があれば指摘してください"
fi
```
## 🔧 Arch Linux / macOS 固有の設定
### Arch Linux
```bash
# AURヘルパーとの統合
function aur-with-claude() {
local package="$1"
yay -G "$package"
cd "$package"
claude "このPKGBUILDをレビューして、セキュリティ上の問題がないか確認してください"
}
```
### macOS
```bash
# Homebrew formula作成支援
function brew-formula-helper() {
local app_name="$1"
claude "Homebrew formulaを作成してください: $app_name"
}
```
## 📊 パフォーマンス最適化
### tmuxでの並列実行
```bash
# 複数のClaude Codeセッションを並列実行
function claude-parallel() {
tmux new-session -d -s claude1 "claude 'タスク1を実行'"
tmux new-session -d -s claude2 "claude 'タスク2を実行'"
tmux new-session -d -s claude3 "claude 'タスク3を実行'"
}
```
### リソース監視
```bash
# Claude Code実行中のリソース使用状況を監視
function claude-monitor() {
claude "$@" &
local pid=$!
while kill -0 $pid 2>/dev/null; do
ps -p $pid -o %cpu,%mem,cmd
sleep 1
done
}
```
## 🔐 セキュリティ考慮事項
1. **APIキーの管理**
```bash
# 環境変数を使用
export ANTHROPIC_API_KEY="$(pass show anthropic/api-key)"
```
2. **サンドボックス実行**
```bash
# Firejailを使用 (Arch Linux)
alias claude-safe='firejail --private claude'
```
3. **監査ログ**
```bash
# すべてのClaude Codeセッションを記録
alias claude='script -a ~/claude-logs/$(date +%Y%m%d-%H%M%S).log claude'
```

104
docs/guides/archlinux-safety.md Normal file
View File

@ -0,0 +1,104 @@
# Arch LinuxでのClaude Code安全利用ガイド
## 推奨セットアップ
### 1. systemd-nspawnコンテナ（最も推奨）
```bash
# インストール
sudo pacman -S arch-install-scripts systemd-container
# コンテナ作成
sudo mkdir -p /var/lib/machines/claude-sandbox
sudo pacstrap -c /var/lib/machines/claude-sandbox base base-devel git nodejs npm python
# コンテナ起動
sudo systemd-nspawn -bD /var/lib/machines/claude-sandbox
# ホストディレクトリをバインド
sudo systemd-nspawn -bD /var/lib/machines/claude-sandbox \
--bind-ro=/home/$USER/projects:/projects
```
### 2. Firejailサンドボックス
```bash
# インストール
sudo pacman -S firejail
# 基本的な使用
firejail --noprofile --private claude
# より厳格な設定
firejail --noprofile --private --noroot --nosound --no3d claude
```
### 3. 安全なpacmanフック
`/etc/pacman.d/hooks/claude-safety.hook`:
```ini
[Trigger]
Operation = Install
Operation = Upgrade
Operation = Remove
Type = Package
Target = *
[Action]
Description = Claude Code安全チェック
When = PreTransaction
Exec = /usr/local/bin/claude-pacman-check.sh
```
### 4. ZFSまたはBtrfsスナップショット
```bash
# Btrfsの場合
sudo btrfs subvolume snapshot -r / /.snapshots/$(date +%Y%m%d-%H%M%S)
# 自動スナップショット
sudo pacman -S snapper
sudo snapper -c root create-config /
sudo snapper -c root create --description "Before Claude Code"
```
### 5. 監査とロギング
```bash
# auditdで監視
sudo pacman -S audit
sudo systemctl enable --now auditd
# 特定のコマンドを監査
sudo auditctl -a always,exit -F path=/usr/bin/rm -F perm=x
```
## Claude Code設定
`~/.claude/settings.json`:
```json
{
"hooks": {
"before_bash": "/usr/local/bin/claude-arch-safety-check.sh"
}
}
```
## 緊急時の復旧
1. **Btrfsスナップショットから復元**
```bash
sudo btrfs subvolume list /
sudo btrfs subvolume set-default <ID> /
```
2. **systemd-nspawnコンテナのリセット**
```bash
sudo rm -rf /var/lib/machines/claude-sandbox
# 再作成
```
3. **パッケージの整合性チェック**
```bash
sudo pacman -Qkk
```

141
docs/guides/custom-commands.md Normal file
View File

@ -0,0 +1,141 @@
# Claude Code カスタムコマンドガイド
## 概要
Claude Codeでは、プロジェクト固有またはユーザー固有のカスタムスラッシュコマンドを作成できます。
## カスタムコマンドの種類
### 1. プロジェクトコマンド
- 場所: `.claude/commands/`
- プレフィックス: `/project:`
- スコープ: 現在のプロジェクト内
### 2. ユーザーコマンド
- 場所: `~/.claude/commands/`
- プレフィックス: `/user:`
- スコープ: すべてのプロジェクト
## 作成したカスタムコマンド
### 基本ヘルプ
```
/project:help
```
Claude Codeの拡張ヘルプを表示します。
### カテゴリ別ヘルプ
```
/project:help/shortcuts # ショートカットキー詳細
/project:help/quickref # クイックリファレンス
/project:help/safety # 安全利用ガイド
```
## カスタムコマンドの作成方法
### 基本構造
```markdown
---
name: コマンド名
description: コマンドの説明
bash: 実行前のbashコマンド（オプション）
---
# コマンドの内容
ここにMarkdown形式でコマンドの内容を記述
```
### 例: 新しいコマンドの作成
```bash
# プロジェクトコマンドとして作成
mkdir -p .claude/commands
echo "プロジェクト固有の情報" > .claude/commands/project-info.md
# ユーザーコマンドとして作成
mkdir -p ~/.claude/commands
echo "個人的なスニペット" > ~/.claude/commands/snippets.md
```
## 高度な機能
### 1. 引数の使用
```markdown
---
name: search
description: コードベースを検索
---
$ARGUMENTSを検索します。
```
使用例: `/project:search TODO`
### 2. bashコマンドの実行
```markdown
---
bash: date +"%Y-%m-%d %H:%M:%S"
---
現在時刻: $BASH_OUTPUT
```
### 3. ファイル参照
```markdown
---
name: readme
---
@README.md
上記はプロジェクトのREADMEです。
```
### 4. ネストされたコマンド
```
.claude/commands/
├── help.md # /project:help
├── help/
│ ├── shortcuts.md # /project:help/shortcuts
│ └── safety.md # /project:help/safety
```
## 使用上のヒント
1. **命名規則**
- わかりやすい名前を使用
- ハイフンまたはアンダースコアで単語を区切る
- 短く覚えやすい名前を選ぶ
2. **説明の重要性**
- `description`フィールドは必ず記入
- コマンドの目的を明確に
3. **保守性**
- 定期的に使わないコマンドは削除
- 類似コマンドは統合を検討
## トラブルシューティング
### コマンドが表示されない
- ファイルが`.md`拡張子であることを確認
- 正しいディレクトリに配置されているか確認
- YAMLフロントマターの構文を確認
### bashコマンドが実行されない
- `bash:`フィールドの構文を確認
- コマンドの実行権限を確認
## 今後の拡張案
1. **チームでの共有**
- `.claude/commands/`をGitで管理
- チーム共通のコマンドセットを作成
2. **テンプレート化**
- よく使うパターンをテンプレート化
- プロジェクトタイプ別のコマンドセット
3. **自動化**
- プロジェクト初期化時にコマンドを自動生成
- 使用頻度に基づく最適化

156
docs/guides/custom-help-setup.md Normal file
View File

@ -0,0 +1,156 @@
# Claude Code カスタムヘルプ機能のセットアップ
## 概要
Claude Codeの標準ヘルプを拡張し、ショートカットキー、公式ドキュメントへのリンク、便利なTipsを統合したカスタムヘルプシステムです。
## インストール
### 1. zshrcへの追加
`.zshrc`に以下を追加：
```bash
# Claude Code ヘルパー関数の読み込み
source "$HOME/git/claude/scripts/claude-zsh-functions.sh"
```
または、直接関数を.zshrcに追加：
```bash
# Claude Code拡張ヘルプ
function claude-help() {
bash "$HOME/git/claude/scripts/claude-help.sh" "$@"
}
# エイリアス
alias ch='claude-help'
alias cr='claude-readme'
```
### 2. スクリプトの配置
```bash
# スクリプトディレクトリの作成
mkdir -p ~/git/claude/scripts
# 実行権限の付与
chmod +x ~/git/claude/scripts/claude-help.sh
chmod +x ~/git/claude/scripts/claude-zsh-functions.sh
```
## 使用方法
### 基本コマンド
```bash
# 全体のヘルプを表示
claude-help
# カテゴリ別ヘルプ
claude-help shortcuts # ショートカットキー詳細
claude-help options # 起動オプション詳細
claude-help docs # 公式ドキュメントリンク
# エイリアス使用
ch # claude-helpの短縮形
cr # クイックリファレンス表示
cs # 安全モードでClaude Code起動
```
### 利用可能な関数
| 関数名 | 説明 | 使用例 |
|--------|------|--------|
| `claude-help` | 拡張ヘルプを表示 | `claude-help [カテゴリ]` |
| `claude-readme` | クイックリファレンス | `claude-readme` |
| `claude-safe` | 安全チェック付き起動 | `claude-safe` |
| `claude-session` | セッション管理 | `claude-session list` |
| `claude-edit-config` | CLAUDE.md編集 | `claude-edit-config` |
| `claude-docs` | 公式ドキュメントを開く | `claude-docs settings` |
## Claude Code内でのカスタムコマンド化
### 方法1: エイリアスとして設定
`~/.claude/settings.json`に追加：
```json
{
"aliases": {
"help+": "!bash ~/git/claude/scripts/claude-help.sh",
"shortcuts": "!bash ~/git/claude/scripts/claude-help.sh shortcuts"
}
}
```
### 方法2: スラッシュコマンドとして実装
Claude Code内で以下のように使用：
```
/help+
```
※ 現在のClaude Codeではカスタムスラッシュコマンドの追加は制限されている可能性があります。
## カスタマイズ
### ヘルプ内容の編集
`scripts/claude-help.sh`を編集して、独自の内容を追加：
```bash
show_category "🔧 カスタムセクション"
cat << 'EOF'
独自の内容をここに追加
EOF
```
### 新しいカテゴリの追加
```bash
case "$1" in
"custom"|"c")
show_category "カスタムカテゴリ"
# 内容を追加
;;
esac
```
## トラブルシューティング
### スクリプトが見つからない
パスを確認：
```bash
which claude-help
echo $HOME/git/claude/scripts/claude-help.sh
```
### 実行権限エラー
```bash
chmod +x ~/git/claude/scripts/*.sh
```
### zsh関数が読み込まれない
```bash
# .zshrcを再読み込み
source ~/.zshrc
```
## 今後の拡張案
1. **インタラクティブメニュー**
- fzfを使った選択式ヘルプ
- カテゴリの動的選択
2. **オンラインヘルプの統合**
- 最新のドキュメントを自動取得
- コミュニティTipsの表示
3. **パーソナライズ**
- 使用頻度に基づくヘルプの最適化
- ユーザー独自のTips追加機能

50
docs/guides/safety-guide.md Normal file
View File

@ -0,0 +1,50 @@
# Claude Code 安全利用ガイド
## 推奨される安全対策
### 1. バックアップ
- 重要なファイルは必ずバックアップ
- Gitでバージョン管理
- Time Machineやスナップショット機能を活用
### 2. Hooksによる制御
```json
// ~/.claude/settings.json
{
"hooks": {
"before_bash": "~/.claude/hooks/command-check.sh"
}
}
```
### 3. 段階的な実行
- まず `--dry-run` オプションで確認
- 小さな変更から始める
- 破壊的な操作は避ける
### 4. 環境の分離
優先度順：
1. **Dockerコンテナ** - 最も安全
2. **仮想マシン** - 完全な分離
3. **専用ユーザー** - 権限を制限
4. **作業用ディレクトリ** - 影響範囲を限定
### 5. Claude Codeへの指示
CLAUDE.mdに安全ルールを記載：
```markdown
## 安全ルール
- `rm -rf` は使用禁止
- システムファイルの変更禁止
- sudoコマンドは確認を求める
- 実行前に影響範囲を説明する
```
### 6. モニタリング
- コマンド履歴の確認
- ファイルシステムの変更監視
- 定期的なログレビュー
## 緊急時の対応
1. Ctrl+C で即座に停止
2. プロセスの強制終了
3. スナップショットから復元

343
mcp/setup-mcp.sh Executable file
View File

@ -0,0 +1,343 @@
#!/bin/bash
# MCP (Model Context Protocol) セットアップスクリプト
set -e
# カラー定義
GREEN='\033[0;32m'
BLUE='\033[0;34m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m'
# 設定ディレクトリ
MCP_DIR="$HOME/.mcp"
CONFIG_FILE="$HOME/.claude/claude_desktop_config.json"
echo -e "${BLUE}MCP (Model Context Protocol) セットアップを開始します${NC}"
# MCPディレクトリの作成
mkdir -p "$MCP_DIR"
# 必要なパッケージのインストール
install_mcp_servers() {
echo -e "${GREEN}MCPサーバーをインストール中...${NC}"
# 基本的なMCPサーバー
npm install -g @modelcontextprotocol/server-filesystem
npm install -g @modelcontextprotocol/server-github
npm install -g @modelcontextprotocol/server-postgres
npm install -g @modelcontextprotocol/server-slack
# 開発系
npm install -g @modelcontextprotocol/server-git
npm install -g @modelcontextprotocol/server-docker
echo -e "${GREEN}✓ MCPサーバーのインストール完了${NC}"
}
# 設定ファイルの作成
create_config() {
echo -e "${GREEN}設定ファイルを作成中...${NC}"
# 既存の設定をバックアップ
if [[ -f "$CONFIG_FILE" ]]; then
cp "$CONFIG_FILE" "$CONFIG_FILE.backup.$(date +%Y%m%d-%H%M%S)"
echo -e "${YELLOW}既存の設定をバックアップしました${NC}"
fi
# 新しい設定を作成
cat > "$CONFIG_FILE" << EOF
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem"],
"env": {
"FILESYSTEM_ROOT": "$HOME/projects"
}
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "your-github-token-here"
}
},
"git": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-git"],
"env": {
"GIT_ROOT": "$HOME/projects"
}
},
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"DATABASE_URL": "postgresql://localhost/postgres"
}
},
"docker": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-docker"]
}
}
}
EOF
echo -e "${GREEN}✓ 設定ファイルを作成しました: $CONFIG_FILE${NC}"
}
# カスタムMCPサーバーの作成
create_custom_server() {
local server_name="$1"
local server_dir="$MCP_DIR/servers/$server_name"
mkdir -p "$server_dir"
# Python版のサンプルMCPサーバー
cat > "$server_dir/server.py" << 'EOF'
#!/usr/bin/env python3
import asyncio
import json
import sys
from typing import Dict, Any, List
from mcp.server import Server
from mcp.types import Tool, TextContent, ImageContent
app = Server("custom-tools")
@app.tool()
async def search_codebase(query: str, file_pattern: str = "*.py") -> TextContent:
"""コードベース全体を検索"""
import subprocess
try:
result = subprocess.run(
["rg", query, "--type", "py", "--json"],
capture_output=True,
text=True
)
return TextContent(text=result.stdout)
except Exception as e:
return TextContent(text=f"エラー: {str(e)}")
@app.tool()
async def get_system_info() -> TextContent:
"""システム情報を取得"""
import platform
import psutil
info = {
"platform": platform.system(),
"machine": platform.machine(),
"processor": platform.processor(),
"memory": f"{psutil.virtual_memory().total // (1024**3)} GB",
"disk": f"{psutil.disk_usage('/').total // (1024**3)} GB"
}
return TextContent(text=json.dumps(info, indent=2))
@app.tool()
async def run_shell_command(command: str) -> TextContent:
"""シェルコマンドを実行（注意: セキュリティリスクあり）"""
import subprocess
# セキュリティ: 危険なコマンドをブロック
dangerous_commands = ["rm -rf", "dd if=", "mkfs", "format"]
if any(cmd in command for cmd in dangerous_commands):
return TextContent(text="エラー: 危険なコマンドです")
try:
result = subprocess.run(
command,
shell=True,
capture_output=True,
text=True,
timeout=30
)
return TextContent(text=f"stdout: {result.stdout}\nstderr: {result.stderr}")
except subprocess.TimeoutExpired:
return TextContent(text="エラー: コマンドがタイムアウトしました")
except Exception as e:
return TextContent(text=f"エラー: {str(e)}")
if __name__ == "__main__":
asyncio.run(app.run())
EOF
# 実行権限を付与
chmod +x "$server_dir/server.py"
# 設定ファイルに追加
echo -e "${GREEN}カスタムMCPサーバーを作成しました: $server_dir${NC}"
echo -e "${YELLOW}設定ファイルに以下を追加してください:${NC}"
cat << EOF
"$server_name": {
"command": "python3",
"args": ["$server_dir/server.py"]
}
EOF
}
# Arch Linux固有の設定
setup_arch_specific() {
echo -e "${GREEN}Arch Linux固有の設定を適用中...${NC}"
# pacmanツール用のMCPサーバー
cat > "$MCP_DIR/servers/pacman/server.py" << 'EOF'
#!/usr/bin/env python3
import asyncio
import subprocess
from mcp.server import Server
from mcp.types import Tool, TextContent
app = Server("pacman-tools")
@app.tool()
async def search_packages(query: str) -> TextContent:
"""パッケージを検索"""
result = subprocess.run(
["pacman", "-Ss", query],
capture_output=True,
text=True
)
return TextContent(text=result.stdout)
@app.tool()
async def get_package_info(package: str) -> TextContent:
"""パッケージ情報を取得"""
result = subprocess.run(
["pacman", "-Si", package],
capture_output=True,
text=True
)
return TextContent(text=result.stdout)
@app.tool()
async def list_installed_packages() -> TextContent:
"""インストール済みパッケージのリスト"""
result = subprocess.run(
["pacman", "-Q"],
capture_output=True,
text=True
)
return TextContent(text=result.stdout)
if __name__ == "__main__":
asyncio.run(app.run())
EOF
chmod +x "$MCP_DIR/servers/pacman/server.py"
mkdir -p "$MCP_DIR/servers/pacman"
}
# macOS固有の設定
setup_macos_specific() {
echo -e "${GREEN}macOS固有の設定を適用中...${NC}"
# Homebrew用のMCPサーバー
cat > "$MCP_DIR/servers/homebrew/server.py" << 'EOF'
#!/usr/bin/env python3
import asyncio
import subprocess
from mcp.server import Server
from mcp.types import Tool, TextContent
app = Server("homebrew-tools")
@app.tool()
async def search_formulae(query: str) -> TextContent:
"""Homebrewのformulaを検索"""
result = subprocess.run(
["brew", "search", query],
capture_output=True,
text=True
)
return TextContent(text=result.stdout)
@app.tool()
async def get_formula_info(formula: str) -> TextContent:
"""formula情報を取得"""
result = subprocess.run(
["brew", "info", formula],
capture_output=True,
text=True
)
return TextContent(text=result.stdout)
@app.tool()
async def list_installed_formulae() -> TextContent:
"""インストール済みformulaのリスト"""
result = subprocess.run(
["brew", "list"],
capture_output=True,
text=True
)
return TextContent(text=result.stdout)
if __name__ == "__main__":
asyncio.run(app.run())
EOF
chmod +x "$MCP_DIR/servers/homebrew/server.py"
mkdir -p "$MCP_DIR/servers/homebrew"
}
# テスト実行
test_mcp() {
echo -e "${GREEN}MCP設定をテスト中...${NC}"
# Claude Codeでテスト
claude "MCPが正常に動作しているかテストしてください。利用可能なツールを確認してください。"
}
# メイン処理
case "$1" in
install)
install_mcp_servers
;;
config)
create_config
;;
custom)
create_custom_server "${2:-custom-tools}"
;;
arch)
setup_arch_specific
;;
macos)
setup_macos_specific
;;
test)
test_mcp
;;
all)
install_mcp_servers
create_config
create_custom_server "custom-tools"
# OS固有の設定
if [[ "$(uname)" == "Linux" ]]; then
setup_arch_specific
elif [[ "$(uname)" == "Darwin" ]]; then
setup_macos_specific
fi
echo -e "${GREEN}✓ MCP設定完了！${NC}"
echo -e "${YELLOW}Claude Codeを再起動してください${NC}"
;;
*)
echo "使用方法: $0 {install|config|custom|arch|macos|test|all}"
echo ""
echo " install - MCPサーバーをインストール"
echo " config - 設定ファイルを作成"
echo " custom - カスタムMCPサーバーを作成"
echo " arch - Arch Linux固有の設定"
echo " macos - macOS固有の設定"
echo " test - 設定をテスト"
echo " all - 全ての設定を実行"
exit 1
;;
esac

184
scripts/ai-integration.sh Executable file
View File

@ -0,0 +1,184 @@
#!/bin/bash
# AI統合ヘルパースクリプト
# カラー定義
GREEN='\033[0;32m'
BLUE='\033[0;34m'
YELLOW='\033[1;33m'
NC='\033[0m'
# 設定
CLAUDE_LOG_DIR="$HOME/claude-logs"
CHATGPT_LOG_DIR="$HOME/chatgpt-logs"
AI_CONTEXT_DIR="$HOME/.ai-context"
# ディレクトリ作成
mkdir -p "$CLAUDE_LOG_DIR" "$CHATGPT_LOG_DIR" "$AI_CONTEXT_DIR"
# ChatGPTの会話をClaude Codeにインポート
import_chatgpt_conversation() {
local chatgpt_file="$1"
local context_name="${2:-imported-context}"
if [[ ! -f "$chatgpt_file" ]]; then
echo -e "${YELLOW}ファイルが見つかりません: $chatgpt_file${NC}"
return 1
fi
# コンテキストファイルを作成
cat > "$AI_CONTEXT_DIR/$context_name.md" << EOF
# インポートされたChatGPT会話
インポート日時: $(date)
ソースファイル: $chatgpt_file
## 会話内容
$(cat "$chatgpt_file")
## Claude Codeへの指示
この会話の内容を踏まえて、以下の点に注意して作業を進めてください：
1. ChatGPTで議論された設計方針を尊重する
2. 未解決の課題があれば解決する
3. 実装の詳細を具体化する
EOF
echo -e "${GREEN}✓ ChatGPT会話をインポートしました: $AI_CONTEXT_DIR/$context_name.md${NC}"
# Claude Codeを起動
claude "以下のChatGPTとの会話を確認して、実装を進めてください: @$AI_CONTEXT_DIR/$context_name.md"
}
# 複数AIで同じタスクを実行して比較
multi_ai_task() {
local task="$1"
local output_dir="$AI_CONTEXT_DIR/comparisons/$(date +%Y%m%d-%H%M%S)"
mkdir -p "$output_dir"
echo -e "${BLUE}複数AIでタスクを実行中...${NC}"
# Claude Code
echo -e "${GREEN}Claude Code:${NC}"
claude "$task" > "$output_dir/claude_response.md" 2>&1
# 他のAI（例：ollama）
if command -v ollama &> /dev/null; then
echo -e "${GREEN}Ollama (llama2):${NC}"
echo "$task" | ollama run llama2 > "$output_dir/ollama_response.md" 2>&1
fi
# 結果を統合
cat > "$output_dir/comparison.md" << EOF
# AI比較結果
タスク: $task
実行日時: $(date)
## Claude Code
\`\`\`
$(cat "$output_dir/claude_response.md")
\`\`\`
## その他のAI
$(ls "$output_dir"/*.md | grep -v comparison.md | while read f; do
echo "### $(basename "$f" .md)"
echo '```'
cat "$f"
echo '```'
done)
## 分析
各AIの回答を比較して、最適なアプローチを選択してください。
EOF
echo -e "${GREEN}✓ 比較結果: $output_dir/comparison.md${NC}"
}
# AIコンテキストチェーン（前のAIの出力を次のAIの入力に）
ai_chain() {
local initial_prompt="$1"
local chain_file="$AI_CONTEXT_DIR/chains/$(date +%Y%m%d-%H%M%S).md"
mkdir -p "$(dirname "$chain_file")"
echo "# AIチェーン実行" > "$chain_file"
echo "開始時刻: $(date)" >> "$chain_file"
echo "初期プロンプト: $initial_prompt" >> "$chain_file"
echo "" >> "$chain_file"
# Step 1: 設計（仮想的なChatGPT応答）
echo "## Step 1: 設計フェーズ" >> "$chain_file"
echo "ChatGPTに設計を依頼..." >> "$chain_file"
# ここでChatGPT APIを呼ぶか、手動で設計を入力
# Step 2: 実装（Claude Code）
echo -e "${BLUE}Claude Codeで実装中...${NC}"
echo "## Step 2: 実装フェーズ (Claude Code)" >> "$chain_file"
claude "$initial_prompt を実装してください。前段の設計を参考に。" | tee -a "$chain_file"
echo -e "${GREEN}✓ AIチェーン完了: $chain_file${NC}"
}
# tmuxセッション管理
setup_ai_tmux() {
local session_name="ai-workspace"
# 既存のセッションをチェック
if tmux has-session -t "$session_name" 2>/dev/null; then
echo -e "${YELLOW}既存のセッションにアタッチします${NC}"
tmux attach -t "$session_name"
return
fi
# 新しいセッションを作成
tmux new-session -d -s "$session_name" -n "claude" "claude --resume"
tmux new-window -t "$session_name" -n "editor" "$EDITOR"
tmux new-window -t "$session_name" -n "terminal"
tmux new-window -t "$session_name" -n "logs" "tail -f $CLAUDE_LOG_DIR/*.log"
# レイアウト設定
tmux select-window -t "$session_name:claude"
tmux split-window -h -p 30 "watch -n 1 'ls -la $CLAUDE_LOG_DIR | tail -10'"
echo -e "${GREEN}✓ tmuxセッション '$session_name' を作成しました${NC}"
tmux attach -t "$session_name"
}
# ヘルプメッセージ
show_help() {
cat << EOF
AI統合ヘルパー
使用方法:
$(basename "$0") import <chatgpt_file> [context_name] - ChatGPT会話をインポート
$(basename "$0") compare <task> - 複数AIでタスクを実行
$(basename "$0") chain <prompt> - AIチェーン実行
$(basename "$0") tmux - AI作業用tmuxセッション作成
$(basename "$0") help - このヘルプを表示
例:
$(basename "$0") import ~/chatgpt-logs/feature-design.md architecture
$(basename "$0") compare "FizzBuzz問題を解いて"
$(basename "$0") chain "RESTful APIを設計して実装"
$(basename "$0") tmux
EOF
}
# メイン処理
case "$1" in
import)
import_chatgpt_conversation "$2" "$3"
;;
compare)
multi_ai_task "$2"
;;
chain)
ai_chain "$2"
;;
tmux)
setup_ai_tmux
;;
help|--help|-h)
show_help
;;
*)
show_help
exit 1
;;
esac

54
scripts/claude-arch-safety-check.sh Executable file
View File

@ -0,0 +1,54 @@
#!/bin/bash
# Arch Linux用のClaude Code安全チェックスクリプト
COMMAND="$1"
# Arch Linux特有の危険なコマンド
ARCH_DANGEROUS=(
"pacman -Rdd" # 依存関係無視の削除
"pacman -Syu --noconfirm" # 確認なしのシステム更新
"rm -rf /boot" # ブートローダー削除
"rm -rf /etc/pacman" # pacman設定削除
"makepkg --asroot" # rootでのパッケージビルド
"yaourt" # 非推奨のAURヘルパー
)
# 警告が必要なコマンド
ARCH_WARNING=(
"pacman -Syu"
"pacman -R"
"systemctl disable"
"systemctl mask"
"mkinitcpio"
"grub-mkconfig"
)
# 基本的な危険コマンドチェック
source "$(dirname "$0")/safe-command-check.sh" 2>/dev/null || true
# Arch特有のチェック
for pattern in "${ARCH_DANGEROUS[@]}"; do
if [[ "$COMMAND" =~ $pattern ]]; then
echo "❌ Arch Linuxで危険なコマンド: $COMMAND"
exit 1
fi
done
for pattern in "${ARCH_WARNING[@]}"; do
if [[ "$COMMAND" =~ $pattern ]]; then
echo "⚠️ システムに影響するコマンド: $COMMAND"
echo "実行前にスナップショットの作成を推奨します"
read -p "続行しますか? (yes/no): " confirm
if [[ "$confirm" != "yes" ]]; then
exit 1
fi
fi
done
# AURヘルパーの使用をチェック
if [[ "$COMMAND" =~ (yay|paru|aurman) ]]; then
echo "📦 AURヘルパーを使用: $COMMAND"
echo "AURパッケージは信頼できるか確認してください"
fi
exit 0

184
scripts/claude-help.sh Executable file
View File

@ -0,0 +1,184 @@
#!/bin/bash
# Claude Code拡張ヘルプコマンド
# カラー定義
BLUE='\033[0;34m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
CYAN='\033[0;36m'
NC='\033[0m'
# ヘルプカテゴリを表示
show_category() {
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}$1${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
}
# メインヘルプ関数
claude_help() {
clear
echo -e "${CYAN}🤖 Claude Code 拡張ヘルプ${NC}\n"
show_category "📝 テキスト入力ショートカット"
cat << 'EOF'
^A (Ctrl+A) ・・・行頭に移動
^E (Ctrl+E) ・・・行末に移動
^B (Ctrl+B) ・・・1文字前に戻る
^F (Ctrl+F) ・・・1文字後に進む
^W (Ctrl+W) ・・・単語単位で削除
^K (Ctrl+K) ・・・カーソル位置から行末まで削除
^U (Ctrl+U) ・・・カーソル位置から行頭まで削除
^J (Ctrl+J) ・・・改行（Enter代替）
^R (Ctrl+R) ・・・履歴検索
EOF
show_category "🎮 Claude Code特有の操作"
cat << 'EOF'
ESC×1 ・・・入力中のテキストを全消去
ESC×2 ・・・前のメッセージに戻る
\ + Enter ・・・複数行入力（確実に動作）
Tab ・・・オートコンプリート
↑/↓ ・・・コマンド履歴
EOF
show_category "🚀 起動オプション"
cat << 'EOF'
claude --resume ・・・前回のセッションを復元
claude --dangerously-skip-permissions ・・・許可確認をスキップ（危険）
claude --thinking ・・・思考プロセスを表示
claude --model MODEL_NAME ・・・特定のモデルを使用
claude IMAGE.png ・・・画像を含めて起動
EOF
show_category "💭 思考モード"
cat << 'EOF'
think ・・・標準的な思考モード
think hard ・・・より深い思考モード
ultrathink ・・・最も深い思考モード（時間がかかる）
EOF
show_category "📚 公式ドキュメント"
cat << 'EOF'
概要 : https://docs.anthropic.com/en/docs/claude-code/overview
クイックスタート: https://docs.anthropic.com/en/docs/claude-code/quickstart
メモリ管理 : https://docs.anthropic.com/en/docs/claude-code/memory
ワークフロー: https://docs.anthropic.com/en/docs/claude-code/common-workflows
設定 : https://docs.anthropic.com/en/docs/claude-code/settings
トラブルシューティング: https://docs.anthropic.com/en/docs/claude-code/troubleshooting
EOF
show_category "🛠️ スラッシュコマンド"
cat << 'EOF'
/help ・・・ヘルプを表示
/clear ・・・会話をクリア
/init ・・・CLAUDE.mdを生成
/web ・・・Web検索を有効化
/exit ・・・セッションを終了
EOF
show_category "⚡ Tips"
cat << 'EOF'
• 画像はクリップボードから直接ペースト可能
• #で始まるメッセージはCLAUDE.mdに追加される
• ~/.claude/settings.jsonで詳細設定が可能
• ~/.claude/CLAUDE.mdでグローバル設定を記述
EOF
echo -e "${YELLOW}詳細は 'claude-help [カテゴリ]' で確認できます${NC}"
echo -e "${YELLOW}カテゴリ: shortcuts, options, thinking, docs, slash, tips${NC}"
}
# カテゴリ別ヘルプ
case "$1" in
"shortcuts"|"s")
show_category "📝 テキスト入力ショートカット詳細"
cat << 'EOF'
基本移動:
^A (Ctrl+A) - カーソルを行頭に移動
^E (Ctrl+E) - カーソルを行末に移動
^B (Ctrl+B) - 1文字左へ移動
^F (Ctrl+F) - 1文字右へ移動
単語移動:
Alt+B - 1単語左へ移動
Alt+F - 1単語右へ移動
削除・編集:
^W (Ctrl+W) - 単語単位で後方削除
^K (Ctrl+K) - カーソル位置から行末まで削除
^U (Ctrl+U) - カーソル位置から行頭まで削除
^D (Ctrl+D) - カーソル位置の文字を削除
^Y (Ctrl+Y) - 最後に削除したテキストを貼り付け
履歴・検索:
^R (Ctrl+R) - インクリメンタル履歴検索
^G (Ctrl+G) - 履歴検索をキャンセル
↑/↓ - コマンド履歴を順番に表示
EOF
;;
"options"|"o")
show_category "🚀 起動オプション詳細"
cat << 'EOF'
セッション管理:
--resume 前回のセッションを復元
--dangerously-skip-permissions 許可確認をスキップ（注意）
思考モード:
--thinking 思考プロセスを表示
モデル選択:
--model claude-3-opus-20240229 特定のモデルを使用
設定:
--settings path/to/settings.json カスタム設定ファイルを使用
その他:
claude IMAGE.png 画像を含めて起動
claude "質問内容" 直接質問を投げる
EOF
;;
"docs"|"d")
show_category "📚 公式ドキュメントリンク"
cat << 'EOF'
基本:
概要: https://docs.anthropic.com/en/docs/claude-code/overview
クイックスタート: https://docs.anthropic.com/en/docs/claude-code/quickstart
機能:
メモリ管理: https://docs.anthropic.com/en/docs/claude-code/memory
ワークフロー: https://docs.anthropic.com/en/docs/claude-code/common-workflows
IDE統合: https://docs.anthropic.com/en/docs/claude-code/ide-integrations
MCP: https://docs.anthropic.com/en/docs/claude-code/mcp
設定・管理:
設定: https://docs.anthropic.com/en/docs/claude-code/settings
フック: https://docs.anthropic.com/en/docs/claude-code/hooks
セキュリティ: https://docs.anthropic.com/en/docs/claude-code/security
トラブルシューティング:
トラブルシューティング: https://docs.anthropic.com/en/docs/claude-code/troubleshooting
その他:
GitHub Issues: https://github.com/anthropics/claude-code/issues
EOF
;;
"")
claude_help
;;
*)
echo "不明なカテゴリ: $1"
echo "利用可能: shortcuts, options, thinking, docs, slash, tips"
;;
esac

139
scripts/claude-zsh-functions.sh Normal file
View File

@ -0,0 +1,139 @@
#!/bin/zsh
# Claude Code用のzsh関数集
# 拡張ヘルプ関数
function claude-help() {
local script_path="${0:a:h}/claude-help.sh"
# スクリプトが見つからない場合のフォールバック
if [[ ! -f "$script_path" ]]; then
script_path="$HOME/git/claude/scripts/claude-help.sh"
fi
if [[ -f "$script_path" ]]; then
bash "$script_path" "$@"
else
echo "Error: claude-help.sh not found"
echo "Expected location: $script_path"
fi
}
# クイックリファレンス（従来の関数を改良）
function claude-readme() {
# カラー定義
local BLUE='\033[0;34m'
local GREEN='\033[0;32m'
local YELLOW='\033[1;33m'
local NC='\033[0m'
echo -e "${GREEN}Claude Code クイックリファレンス${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo '
ショートカット:
^A/^E ・・・行頭/行末に移動
^B/^F ・・・1文字前/後に移動
^W ・・・単語削除（高速）
^J ・・・改行（Enter代替）
Claude特有:
ESC×1 ・・・入力を全消去
ESC×2 ・・・前のメッセージに戻る
\ + Enter ・・・複数行入力
よく使うコマンド:
claude --resume ・・・セッション復元
claude --dangerously-skip-permissions ・・・許可スキップ
think / think hard / ultrathink ・・・思考モード
'
echo -e "${YELLOW}詳細は 'claude-help' で確認${NC}"
}
# Claude Codeセッションの管理
function claude-session() {
case "$1" in
"save")
# 現在のセッションIDを保存
echo "Session saved (use 'claude --resume' to restore)"
;;
"list")
# 利用可能なセッションをリスト
ls -la ~/.claude/sessions/ 2>/dev/null || echo "No sessions found"
;;
*)
echo "Usage: claude-session [save|list]"
;;
esac
}
# Claude Code用の安全チェック付き実行
function claude-safe() {
local hooks_dir="$HOME/git/claude/scripts"
# 安全チェックスクリプトを設定
export CLAUDE_BEFORE_BASH="$hooks_dir/claude-arch-safety-check.sh"
# Claude Codeを起動
claude "$@"
# 環境変数をクリア
unset CLAUDE_BEFORE_BASH
}
# プロジェクト固有のCLAUDE.mdを編集
function claude-edit-config() {
local config_file="CLAUDE.md"
if [[ ! -f "$config_file" ]]; then
echo "Creating new CLAUDE.md..."
cat > "$config_file" << 'EOF'
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## Project Overview
[プロジェクトの概要をここに記載]
## Commands
[よく使うコマンドをここに記載]
## Architecture
[アーキテクチャの説明をここに記載]
EOF
fi
${EDITOR:-vim} "$config_file"
}
# Claude Codeのドキュメントを開く
function claude-docs() {
local topic="${1:-overview}"
local base_url="https://docs.anthropic.com/en/docs/claude-code"
case "$topic" in
"shortcuts"|"keys")
open "$base_url/interactive-mode" 2>/dev/null || xdg-open "$base_url/interactive-mode"
;;
"settings")
open "$base_url/settings" 2>/dev/null || xdg-open "$base_url/settings"
;;
"memory")
open "$base_url/memory" 2>/dev/null || xdg-open "$base_url/memory"
;;
*)
open "$base_url/$topic" 2>/dev/null || xdg-open "$base_url/$topic"
;;
esac
}
# エイリアス定義
alias ch='claude-help'
alias cr='claude-readme'
alias cs='claude-safe'
alias ce='claude-edit-config'
alias cd-docs='claude-docs'
# 初回実行時のメッセージ
if [[ -z "$CLAUDE_ZSH_LOADED" ]]; then
export CLAUDE_ZSH_LOADED=1
echo "Claude Code helper functions loaded. Type 'claude-help' for more info."
fi

47
scripts/safe-command-check.sh Executable file
View File

@ -0,0 +1,47 @@
#!/bin/bash
# Claude Code用の安全なコマンドチェッカー
COMMAND="$1"
# 危険なコマンドパターン
DANGEROUS_PATTERNS=(
"rm -rf /"
"rm -rf ~"
":(){ :|:& };:" # Fork bomb
"> /dev/sda"
"dd if=/dev/zero"
"mkfs"
"format"
)
# 確認が必要なコマンド
CONFIRM_PATTERNS=(
"sudo"
"rm -rf"
"git push --force"
"npm publish"
"pip install"
)
# 危険なコマンドをチェック
for pattern in "${DANGEROUS_PATTERNS[@]}"; do
if [[ "$COMMAND" =~ $pattern ]]; then
echo "❌ 危険なコマンドを検出しました: $COMMAND"
echo "このコマンドは実行できません。"
exit 1
fi
done
# 確認が必要なコマンドをチェック
for pattern in "${CONFIRM_PATTERNS[@]}"; do
if [[ "$COMMAND" =~ $pattern ]]; then
echo "⚠️ 確認が必要なコマンド: $COMMAND"
read -p "本当に実行しますか? (yes/no): " confirm
if [[ "$confirm" != "yes" ]]; then
echo "コマンドをキャンセルしました。"
exit 1
fi
fi
done
echo "✅ コマンドは安全です: $COMMAND"

57
scripts/setup-help.sh Executable file
View File

@ -0,0 +1,57 @@
#!/bin/bash
# Claude Code カスタムヘルプのセットアップスクリプト
set -e
# カラー定義
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m'
echo -e "${GREEN}Claude Code カスタムヘルプをセットアップします${NC}"
# スクリプトディレクトリの確認
SCRIPT_DIR="$HOME/git/claude/scripts"
if [[ ! -d "$SCRIPT_DIR" ]]; then
echo -e "${YELLOW}スクリプトディレクトリを作成します...${NC}"
mkdir -p "$SCRIPT_DIR"
fi
# 実行権限の付与
echo -e "${GREEN}実行権限を設定中...${NC}"
chmod +x "$SCRIPT_DIR"/*.sh 2>/dev/null || true
# .zshrcへの追加確認
ZSHRC="$HOME/.zshrc"
SOURCE_LINE="source \"\$HOME/git/claude/scripts/claude-zsh-functions.sh\""
if grep -q "claude-zsh-functions.sh" "$ZSHRC" 2>/dev/null; then
echo -e "${YELLOW}既に.zshrcに設定があります${NC}"
else
echo -e "${GREEN}.zshrcに設定を追加しますか？${NC}"
read -p "続行しますか? (y/N): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
echo "" >> "$ZSHRC"
echo "# Claude Code Helper Functions" >> "$ZSHRC"
echo "$SOURCE_LINE" >> "$ZSHRC"
echo -e "${GREEN}✓ .zshrcに追加しました${NC}"
else
echo -e "${YELLOW}手動で以下を.zshrcに追加してください:${NC}"
echo "$SOURCE_LINE"
fi
fi
# テスト実行
echo -e "\n${GREEN}セットアップ完了！${NC}"
echo -e "${YELLOW}以下のコマンドでテストしてください:${NC}"
echo " source ~/.zshrc"
echo " claude-help"
echo ""
echo -e "${GREEN}利用可能なコマンド:${NC}"
echo " claude-help - 拡張ヘルプ表示"
echo " ch - claude-helpの短縮形"
echo " cr - クイックリファレンス"
echo " cs - 安全モードで起動"
echo " claude-docs - 公式ドキュメントを開く"

304
setup-advanced.sh Executable file
View File

@ -0,0 +1,304 @@
#!/bin/bash
# Claude Code Advanced Setup Script
# ターミナル環境との統合、AI連携、MCP設定を一括で行う
set -e
# カラー定義
GREEN='\033[0;32m'
BLUE='\033[0;34m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m'
# 設定
CLAUDE_DIR="$HOME/git/claude"
BACKUP_DIR="$HOME/.claude-backup-$(date +%Y%m%d-%H%M%S)"
echo -e "${BLUE}🤖 Claude Code Advanced Setup${NC}"
echo -e "${BLUE}===============================${NC}"
# バックアップ作成
create_backup() {
echo -e "${GREEN}既存設定のバックアップを作成中...${NC}"
mkdir -p "$BACKUP_DIR"
# 既存の設定をバックアップ
[[ -f ~/.zshrc ]] && cp ~/.zshrc "$BACKUP_DIR/"
[[ -f ~/.claude/settings.json ]] && cp ~/.claude/settings.json "$BACKUP_DIR/"
[[ -f ~/.claude/claude_desktop_config.json ]] && cp ~/.claude/claude_desktop_config.json "$BACKUP_DIR/"
[[ -f ~/.tmux.conf ]] && cp ~/.tmux.conf "$BACKUP_DIR/"
echo -e "${GREEN}✓ バックアップ完了: $BACKUP_DIR${NC}"
}
# 依存関係のインストール
install_dependencies() {
echo -e "${GREEN}依存関係をインストール中...${NC}"
# OS検出
if [[ "$(uname)" == "Darwin" ]]; then
# macOS
if ! command -v brew &> /dev/null; then
echo -e "${RED}Homebrewがインストールされていません${NC}"
echo "https://brew.sh/ からインストールしてください"
exit 1
fi
brew install ripgrep fd bat exa tmux git nodejs npm
elif [[ "$(uname)" == "Linux" ]]; then
# Linux (Arch Linux想定)
if command -v pacman &> /dev/null; then
sudo pacman -S --noconfirm ripgrep fd bat exa tmux git nodejs npm
elif command -v apt &> /dev/null; then
sudo apt update
sudo apt install -y ripgrep fd-find bat exa tmux git nodejs npm
fi
fi
echo -e "${GREEN}✓ 依存関係のインストール完了${NC}"
}
# zsh設定
setup_zsh() {
echo -e "${GREEN}zsh設定を構成中...${NC}"
# .zshrcに追加
if ! grep -q "source.*zshrc_claude" ~/.zshrc 2>/dev/null; then
echo "" >> ~/.zshrc
echo "# Claude Code Enhanced Configuration" >> ~/.zshrc
echo "source $CLAUDE_DIR/shell-config/.zshrc_claude" >> ~/.zshrc
echo -e "${GREEN}✓ .zshrcに設定を追加しました${NC}"
else
echo -e "${YELLOW}既に.zshrcに設定があります${NC}"
fi
}
# tmux設定
setup_tmux() {
echo -e "${GREEN}tmux設定を構成中...${NC}"
if [[ ! -f ~/.tmux.conf ]]; then
cat > ~/.tmux.conf << 'EOF'
# Claude Code tmux configuration
# プレフィックスキーの変更
set -g prefix C-a
unbind C-b
bind C-a send-prefix
# ペインの分割
bind | split-window -h
bind - split-window -v
# ペインの移動
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R
# Claude Code専用のキーバインド
bind C command-prompt -p "claude prompt:" "new-window 'claude \"%%\"'"
bind c-r new-window "claude --resume"
# ステータスラインの設定
set -g status-left '[#S] '
set -g status-right '%Y-%m-%d %H:%M'
set -g window-status-current-style 'bg=green,fg=black'
# マウスサポート
set -g mouse on
# 256色対応
set -g default-terminal "screen-256color"
EOF
echo -e "${GREEN}✓ tmux設定ファイルを作成しました${NC}"
else
echo -e "${YELLOW}既存のtmux設定があります${NC}"
fi
}
# MCP設定
setup_mcp() {
echo -e "${GREEN}MCP設定を構成中...${NC}"
# MCPセットアップスクリプトを実行
chmod +x "$CLAUDE_DIR/mcp/setup-mcp.sh"
bash "$CLAUDE_DIR/mcp/setup-mcp.sh" all
echo -e "${GREEN}✓ MCP設定完了${NC}"
}
# AI統合設定
setup_ai_integration() {
echo -e "${GREEN}AI統合機能を設定中...${NC}"
# スクリプトに実行権限を付与
chmod +x "$CLAUDE_DIR/scripts/ai-integration.sh"
# 必要なディレクトリを作成
mkdir -p "$HOME/claude-logs"
mkdir -p "$HOME/chatgpt-logs"
mkdir -p "$HOME/.ai-context"
echo -e "${GREEN}✓ AI統合機能の設定完了${NC}"
}
# Claude Code設定
setup_claude_settings() {
echo -e "${GREEN}Claude Code設定を構成中...${NC}"
mkdir -p ~/.claude
# settings.jsonの作成
cat > ~/.claude/settings.json << 'EOF'
{
"editor": "vim",
"theme": "dark",
"hooks": {
"before_bash": "~/git/claude/scripts/safe-command-check.sh"
},
"thinking": {
"enabled": true,
"depth": "normal"
}
}
EOF
echo -e "${GREEN}✓ Claude Code設定ファイルを作成しました${NC}"
}
# Vim統合設定
setup_vim() {
echo -e "${GREEN}Vim統合設定を構成中...${NC}"
# .vimrcに追加
if [[ -f ~/.vimrc ]]; then
if ! grep -q "Claude Code" ~/.vimrc; then
cat >> ~/.vimrc << 'EOF'
" Claude Code integration
nnoremap <leader>cc :!claude "このコードをレビューして: %"<CR>
nnoremap <leader>ce :!claude "このエラーを解決して: %"<CR>
nnoremap <leader>ct :!claude "このファイルのテストを作成して: %"<CR>
vnoremap <leader>cs :w !claude "この部分を説明して"<CR>
EOF
echo -e "${GREEN}✓ Vim設定を追加しました${NC}"
else
echo -e "${YELLOW}既にVim設定があります${NC}"
fi
fi
}
# 権限設定
setup_permissions() {
echo -e "${GREEN}実行権限を設定中...${NC}"
# すべてのスクリプトに実行権限を付与
find "$CLAUDE_DIR/scripts" -name "*.sh" -exec chmod +x {} \;
find "$CLAUDE_DIR/mcp" -name "*.sh" -exec chmod +x {} \;
chmod +x "$CLAUDE_DIR/setup-advanced.sh"
echo -e "${GREEN}✓ 権限設定完了${NC}"
}
# テスト実行
run_tests() {
echo -e "${GREEN}設定をテスト中...${NC}"
# 基本的な動作確認
echo "zsh設定テスト..."
if source "$CLAUDE_DIR/shell-config/.zshrc_claude"; then
echo -e "${GREEN}✓ zsh設定OK${NC}"
else
echo -e "${RED}✗ zsh設定エラー${NC}"
fi
echo -e "${GREEN}✓ テスト完了${NC}"
}
# 使用方法の表示
show_usage() {
echo -e "${BLUE}使用方法:${NC}"
echo " $0 all - 全ての設定を実行"
echo " $0 deps - 依存関係のインストール"
echo " $0 zsh - zsh設定"
echo " $0 tmux - tmux設定"
echo " $0 mcp - MCP設定"
echo " $0 ai - AI統合設定"
echo " $0 claude - Claude Code設定"
echo " $0 vim - Vim統合設定"
echo " $0 test - 設定テスト"
echo " $0 help - このヘルプ"
echo ""
echo -e "${YELLOW}推奨: $0 all で全設定を実行${NC}"
}
# 完了メッセージ
show_completion() {
echo -e "${GREEN}🎉 Claude Code Advanced Setup完了！${NC}"
echo ""
echo -e "${BLUE}次の手順:${NC}"
echo "1. ターミナルを再起動するか 'source ~/.zshrc' を実行"
echo "2. 'claude-env' コマンドで環境をテスト"
echo "3. 'ai-tmux' でClaude Code作業環境を起動"
echo "4. '/user:help' でカスタムヘルプを確認"
echo ""
echo -e "${YELLOW}利用可能な新機能:${NC}"
echo "- claude-analyze <file> - ファイル解析"
echo "- claude-review <file> - コードレビュー"
echo "- claude-test <file> - テスト生成"
echo "- ai-compare <task> - 複数AI比較"
echo "- ai-import <log> - ChatGPT会話インポート"
echo "- mcp-setup - MCP設定"
echo ""
echo -e "${GREEN}Happy coding with Claude Code! 🚀${NC}"
}
# メイン処理
case "$1" in
all)
create_backup
install_dependencies
setup_zsh
setup_tmux
setup_mcp
setup_ai_integration
setup_claude_settings
setup_vim
setup_permissions
run_tests
show_completion
;;
deps)
install_dependencies
;;
zsh)
setup_zsh
;;
tmux)
setup_tmux
;;
mcp)
setup_mcp
;;
ai)
setup_ai_integration
;;
claude)
setup_claude_settings
;;
vim)
setup_vim
;;
test)
run_tests
;;
help|--help|-h)
show_usage
;;
*)
show_usage
exit 1
;;
esac

239
shell-config/.zshrc_claude Normal file
View File

@ -0,0 +1,239 @@
# Claude Code Enhanced Shell Configuration
# Source this file in your .zshrc: source ~/.zshrc_claude
# 基本的なエイリアス
alias c='claude'
alias cr='claude --resume'
alias ct='claude --thinking'
alias cs='claude --dangerously-skip-permissions'
# AI統合エイリアス
alias ai-import='bash ~/git/claude/scripts/ai-integration.sh import'
alias ai-compare='bash ~/git/claude/scripts/ai-integration.sh compare'
alias ai-chain='bash ~/git/claude/scripts/ai-integration.sh chain'
alias ai-tmux='bash ~/git/claude/scripts/ai-integration.sh tmux'
# MCP関連エイリアス
alias mcp-setup='bash ~/git/claude/mcp/setup-mcp.sh'
alias mcp-test='bash ~/git/claude/mcp/setup-mcp.sh test'
# 便利な関数群
# Claude Codeでファイルを解析
function claude-analyze() {
local file="$1"
if [[ -f "$file" ]]; then
claude "このファイルを解析してください: @$file"
else
echo "ファイルが見つかりません: $file"
fi
}
# Claude Codeでエラーを解決
function claude-debug() {
local error_file="${1:-/tmp/last_error.log}"
if [[ -f "$error_file" ]]; then
claude "このエラーを解決してください: $(cat $error_file)"
else
echo "エラーファイルが見つかりません: $error_file"
fi
}
# Claude Codeでコードレビュー
function claude-review() {
local target="${1:-.}"
if [[ -d "$target" ]]; then
# ディレクトリの場合、変更されたファイルをレビュー
git diff --name-only | head -10 | while read file; do
claude "このファイルの変更をレビューしてください: @$file"
done
elif [[ -f "$target" ]]; then
# ファイルの場合、そのファイルをレビュー
claude "このファイルをレビューしてください: @$target"
else
echo "ターゲットが見つかりません: $target"
fi
}
# Claude Codeでドキュメント生成
function claude-docs() {
local target="${1:-.}"
claude "このプロジェクトのドキュメントを生成してください。プロジェクトの構造: $(tree -L 2 $target)"
}
# Claude Codeでテストケース生成
function claude-test() {
local file="$1"
if [[ -f "$file" ]]; then
claude "このファイルのテストケースを生成してください: @$file"
else
echo "ファイルが見つかりません: $file"
fi
}
# Claude Codeでリファクタリング
function claude-refactor() {
local file="$1"
local instruction="${2:-コードを改善してください}"
if [[ -f "$file" ]]; then
claude "$instruction: @$file"
else
echo "ファイルが見つかりません: $file"
fi
}
# 現在の作業状況をClaude Codeに伝える
function claude-status() {
local status_info=$(cat << EOF
現在の作業状況:
- ディレクトリ: $(pwd)
- ブランチ: $(git branch --show-current 2>/dev/null || echo "Git管理外")
- 変更されたファイル: $(git status --porcelain 2>/dev/null | head -5)
- 最新コミット: $(git log --oneline -1 2>/dev/null)
- プロセス: $(ps aux | grep -E "(vim|tmux|docker)" | head -3)
何かお手伝いできることはありますか？
EOF
)
claude "$status_info"
}
# Claude Codeで環境設定
function claude-env() {
local env_info=$(cat << EOF
現在の環境情報:
- OS: $(uname -s)
- アーキテクチャ: $(uname -m)
- シェル: $SHELL
- ターミナル: $TERM
- エディタ: $EDITOR
- Python: $(python3 --version 2>/dev/null || echo "インストールされていません")
- Node.js: $(node --version 2>/dev/null || echo "インストールされていません")
- Git: $(git --version 2>/dev/null || echo "インストールされていません")
この環境での開発をサポートしてください。
EOF
)
claude "$env_info"
}
# tmux統合
function claude-tmux() {
local session_name="claude-work"
# 既存のセッションをチェック
if tmux has-session -t "$session_name" 2>/dev/null; then
echo "既存のセッションにアタッチします..."
tmux attach -t "$session_name"
return
fi
# 新しいセッションを作成
tmux new-session -d -s "$session_name" -n "claude" "claude --resume"
tmux new-window -t "$session_name" -n "editor"
tmux new-window -t "$session_name" -n "terminal"
tmux new-window -t "$session_name" -n "logs" "tail -f ~/.claude/logs/*.log 2>/dev/null || echo 'ログファイルが見つかりません'"
# レイアウト設定
tmux select-window -t "$session_name:claude"
tmux split-window -h -p 30
tmux send-keys -t "$session_name:claude.1" "echo 'Claude Code作業中...'" Enter
echo "Claude Code作業用セッションを作成しました"
tmux attach -t "$session_name"
}
# vim統合
function claude-vim() {
local file="$1"
if [[ -n "$file" ]]; then
# ファイルが指定された場合、vimで開いてからClaude Codeに送る
vim "$file"
claude "先ほど編集したファイルについて質問があります: @$file"
else
# ファイルが指定されない場合、現在のディレクトリの情報を送る
claude "現在のディレクトリで作業しています: $(pwd)\n$(ls -la)"
fi
}
# 自動エラー捕捉
function claude-exec() {
local cmd="$*"
local error_file="/tmp/claude_error_$(date +%s).log"
echo "実行中: $cmd"
# コマンドを実行し、エラーをキャプチャ
if ! eval "$cmd" 2>"$error_file"; then
echo "エラーが発生しました。Claude Codeに解決を依頼します..."
claude "次のコマンドでエラーが発生しました: $cmd\n\nエラー内容:\n$(cat $error_file)"
rm -f "$error_file"
else
echo "コマンドが正常に完了しました"
rm -f "$error_file"
fi
}
# プロジェクト初期化
function claude-init() {
local project_name="$1"
local project_type="${2:-general}"
if [[ -z "$project_name" ]]; then
echo "使用方法: claude-init <プロジェクト名> [プロジェクトタイプ]"
return 1
fi
mkdir -p "$project_name"
cd "$project_name"
# CLAUDE.mdを作成
cat > CLAUDE.md << EOF
# CLAUDE.md
This file provides guidance to Claude Code when working with this project.
## Project: $project_name
Type: $project_type
Created: $(date)
## Development Guidelines
- Follow best practices for $project_type development
- Maintain consistent code style
- Write comprehensive tests
- Document all public APIs
## Commands
[Add common commands here]
## Architecture
[Add architecture notes here]
EOF
# Git初期化
git init
echo "CLAUDE.md" > .gitignore
echo "*.log" >> .gitignore
echo ".DS_Store" >> .gitignore
# Claude Codeを起動
claude "新しいプロジェクト '$project_name' ($project_type) を初期化しました。開発を開始するのを手伝ってください。"
}
# 補完設定（zsh）
if [[ -n "$ZSH_VERSION" ]]; then
# カスタム補完
compdef '_files' claude-analyze
compdef '_files' claude-review
compdef '_files' claude-test
compdef '_files' claude-refactor
compdef '_files' claude-vim
fi
# 起動メッセージ
echo "🤖 Claude Code enhanced shell configuration loaded!"
echo "主要コマンド: c, cr, ct, cs, claude-analyze, claude-review, claude-test"
echo "詳細: alias | grep claude"