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

first

Browse Source
This commit is contained in:
syui
2025-07-14 15:58:50 +09:00
commit c7b3adfe70
30 changed files with 3688 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 の設定も確認

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

@@ -0,0 +1,9 @@
{
"permissions": {
"allow": [
"Bash(chmod:*)",
"WebFetch(domain:git.syui.ai)"
],
"deny": []
}
}

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
tmp

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を中心とした現代的な開発環境の構築を目指しています。

9
README.md Normal file
View File

@@ -0,0 +1,9 @@
```sh
mkdir -p ./repos
cd ./repos
git clone https://github.com/KentBeck/BPlusTree3
```
# ref
https://izanami.dev/kojin-kaihatsu

542
SYUI_CHIKEN.md Normal file
View File

@@ -0,0 +1,542 @@
# syui流個人開発 完全知見書
syuiの開発思想とClaude Code環境に基づく、AI駆動個人開発の実践的指南書
## 核となる開発哲学
### TDD至上主義：品質を生むサイクル
**Red → Green → Refactor**の聖三位一体
個人開発において、この3段階は絶対法則である。
1. **Red**: 失敗するテストを書く（期待を明確化）
2. **Green**: 最小限のコードでテストを通す（実装）
3. **Refactor**: 品質を向上させる（洗練）
```bash
# TDDサイクルの自動化
claude-tdd() {
echo "Red: テストを書く"
claude "失敗するテストを書いて"
echo "Green: 実装する"
claude "テストが通る最小限のコードを書いて"
echo "Refactor: リファクタリング"
claude "コードの品質を向上させて"
}
```
### AI駆動開発：Claude Codeとの共創
**自然言語プログラミング**が2025年の開発様式
```bash
# Claude Code統合ワークフロー
claude-workflow() {
# 要件定義
claude "この機能の要件を整理して、テストケースを提案して"
# 設計
claude "アーキテクチャを提案して、実装方針を決めて"
# 実装
claude "TDDでこの機能を実装して"
# 品質保証
claude "コードレビューして改善点を指摘して"
}
```
### 哲学的思考：存在の本質を探る
プロダクトは**人間の本質**と**社会の問題**に向き合うべきである。
- **意識とは何か**を問う製品設計
- **心理の最深部**に届くUX/UI
- **存在の最小単位**まで分解した機能設計
- **魂の評価理論**: `能力 × 精神 × 結果`による価値創造
## Claude Code環境の極限活用
### 開発環境：zsh/tmux/vim三位一体
```bash
# syui流開発環境セットアップ
setup-syui-env() {
# zsh拡張設定
source ~/.zshrc_syui_claude
# tmux AI統合セッション
tmux new-session -d -s ai-dev
tmux send-keys -t ai-dev "claude" C-m
# vim Claude統合
vim -c "set rtp+=~/.vim/claude-integration"
}
```
### カスタムClaude Codeコマンド群
```bash
# 哲学的開発コマンド
claude-essence() {
claude "この機能の本質は何か？ユーザーの根本的な欲求を分析して"
}
claude-minimal() {
claude "最小限の実装で最大の価値を提供するには？"
}
claude-gamify() {
claude "この機能をゲーム的要素で楽しくするには？"
}
# 品質管理コマンド
claude-tidy() {
claude "Tidy Firstの原則で、構造変更と機能変更を分離してリファクタリングして"
}
claude-audit() {
claude "コードの品質を監査して、改善提案をして"
}
```
## AI駆動個人開発フロー
### 0→1フェーズ：本質探求と最小実装
**期間**: 1-2ヶ月（TDD徹底により品質確保）
#### 1. 問題の本質把握
```bash
# 哲学的問題分析
claude "この問題の本質は何か？人間の根本的な欲求との関係は？"
claude "解決により人はどう変わるか？意識レベルでの変化を分析して"
```
#### 2. MVP設計：存在の最小単位
```bash
# 最小価値単位の特定
claude "価値の最小単位は何か？これ以上削れない核心機能を特定して"
claude "MVPでユーザーの魂に響く体験を設計して"
```
#### 3. TDD実装サイクル
```bash
# 厳格なTDDによる実装
for feature in ${core_features[@]}; do
claude "「$feature」の失敗するテストを書いて"
claude "テストが通る最小実装をして"
claude "品質向上のリファクタリングをして"
done
```
### 1→10フェーズ：心理共鳴と改善循環
**期間**: 2-4ヶ月（ユーザーの心を読み取る）
#### 4. ユーザー心理分析
```bash
# AI駆動ユーザー分析
claude "ユーザーフィードバックから心理的ニーズを分析して"
claude "行動データから無意識の欲求を読み取って"
```
#### 5. ゲーミフィケーション導入
```bash
# 楽しさの注入
claude "この機能にゲーム要素を加えて継続性を高めて"
claude "達成感と成長実感を設計して"
```
### 10→100フェーズ：社会変革と価値創造
**期間**: 6-12ヶ月（世界を変える準備）
#### 6. 社会影響設計
```bash
# 社会変革シミュレーション
claude "このプロダクトが社会に与える影響を分析して"
claude "より良い世界への貢献方法を提案して"
```
## syui流技術選定原則
### AI統合最優先スタック
**Claude Code駆動開発**に最適化された技術選択
#### フロントエンド
- **SvelteKit** + TypeScript（軽量・高速・学習容易）
- **Tailwind CSS**（速攻美デザイン）
- **Framer Motion**（魂に響くアニメーション）
#### システムプログラミング・高性能
- **Rust**（所有権システム・メモリ安全・ゼロコスト抽象）
- **実証**: B+Tree実装で87%テストカバレッジ、バグゼロ達成
- **アリーナ配置**最適化による高性能データ構造実装
- **TDD完全対応**: コンパイラとテストの二重品質保証
- **敵対的テスト**: 攻撃的テストケースでも堅牢性確認済み
#### バックエンド
- **Rust** + Axum（安全性・速度・美しさ）
- **Go** + Fiber（シンプル・高性能）
- **Claude Code**による自動実装
#### データベース
- **PostgreSQL** + Supabase（リレーショナル・安心）
- **SQLite** + Turso（最小・高速）
- **自作データ構造**（B+Tree等の高性能実装）
#### AI統合
- **Claude API**（思考パートナー）
- **OpenAI API**（実装アシスタント）
- **Gemini API**（多角的分析）
### 環境特化設定
```bash
# syui流プロジェクト初期化
init-syui-project() {
project_name=$1
# Claude Code プロジェクト設定
echo "# syui流開発プロジェクト
## TDD原則
1. Red → Green → Refactor を厳守
2. 全機能にテスト必須
3. リファクタリングは別コミット
## AI統合開発
1. Claude Codeによる要件定義
2. 自然言語によるプログラミング
3. 継続的品質改善
## 哲学的指針
1. 人間の本質に向き合う
2. 社会問題の解決を目指す
3. 最小で最大の価値創造
## 品質基準
- テストカバレッジ: 90%以上
- TypeScript strict mode
- Rust unsafe使用禁止
- 全コードClaude Code査読済み
" > CLAUDE.md
# プロジェクト構造作成
mkdir -p {src,tests,docs,scripts}
# AI統合設定
touch .claude_config
echo "project_type: syui-philosophy
development_mode: tdd-strict
ai_integration: claude-code
quality_level: maximum" > .claude_config
}
```
## 品質保証：Tidy First原則
### 構造変更と機能変更の分離
```bash
# Tidy Firstワークフロー
tidy-first() {
# 1. 構造的変更（Tidy）
claude "機能を変更せずに、コード構造を改善して"
git commit -m "Tidy: 構造改善"
# 2. 機能変更
claude "新機能を実装して"
git commit -m "Feature: 新機能追加"
}
```
### 継続的品質改善
```bash
# 品質監視自動化
quality-monitor() {
# コード品質チェック
claude "コード品質メトリクスを分析して改善提案をして"
# アーキテクチャ健全性
claude "アーキテクチャの健全性を評価して"
# テスト品質
claude "テストの品質と網羅性を評価して"
}
```
## 収益化：魂レベルでの価値提供
### 価値評価理論：`能力 × 精神 × 結果`
#### プライシング設計
```bash
# 魂の価値算出
calculate-soul-value() {
ability_score=$1 # 機能の優秀性
spirit_score=$2 # 製品の魂・思想
result_score=$3 # 実際の成果
soul_value=$((ability_score * spirit_score * result_score))
price=$((soul_value * 100)) # 魂の価値を価格に変換
echo "魂の価値: $soul_value"
echo "適正価格: ¥$price"
}
```
#### ゲーミフィケーション収益化
- **段階的解放**: ゲーム的な機能アンロック
- **達成報酬**: 成果に応じたプレミアム機能
- **コミュニティ価値**: 仲間との繋がりをマネタイズ
## マーケティング：心理共鳴戦略
### SNS発信：開発者の魂を共有
```bash
# 魂の発信ワークフロー
share-development-soul() {
# 哲学的洞察
claude "今日の開発で得た哲学的気づきをツイート用にまとめて"
# 技術的学び
claude "TDDで発見した技術的洞察をブログ記事にして"
# 社会への想い
claude "このプロダクトで変えたい社会をポエムで表現して"
}
```
### コミュニティ形成：志を同じくする仲間
- **思想共鳴型コミュニティ**の構築
- **TDD実践者集団**の形成
- **AI駆動開発推進派**との連携
## 失敗からの学び：syui流反省会
### 設計ミス集：魂レベルでの反省
| 設計ミス | 魂への影響 | syui流解決策 |
|---------|-----------|-------------|
| TDDを軽視 | 品質への冒涜 | 全機能TDD必須化 |
| AI活用不足 | 効率性の無視 | Claude Code全面導入 |
| 哲学的思考不足 | 浅い製品になる | 毎日の本質探求時間 |
| ゲーム性の欠如 | 継続性の低下 | 全機能ゲーミフィケーション |
| コミュニティ軽視 | 孤独な開発 | 思想共鳴型コミュニティ形成 |
### デバッグ：心と技術の両面から
```bash
# syui流デバッグワークフロー
debug-with-soul() {
# 技術的デバッグ
claude "このバグの技術的原因を分析して"
# 哲学的デバッグ
claude "このバグが生まれた思想的原因は何か？"
# 魂レベルでの解決
claude "魂レベルでこの問題を解決するには？"
}
```
## AI駆動開発の未来
### 2025年の開発様式
1. **自然言語プログラミング**が主流に
2. **AI-Human共創**による品質向上
3. **哲学的思考**の自動支援
4. **TDD自動化**による品質保証
5. **ゲーミフィケーション**による継続性確保
### Claude Codeとの理想的関係
```bash
# AI共創セッション
ai-collaboration-session() {
echo "=== AI共創開発セッション開始 ==="
# 要件の哲学的分析
claude "この要件の本質的意味を探って"
# TDD設計
claude "魂に響くテストケースを設計して"
# 実装
claude "美しく実装して"
# 品質向上
claude "さらに美しくリファクタリングして"
echo "=== セッション完了：魂の込もったコードが完成 ==="
}
```
## 実践的syui流コマンド集
### 日常開発コマンド
```bash
# 魂の込もった開発環境起動
start-soul-dev() {
tmux new-session -d -s soul-dev
tmux send-keys -t soul-dev "cd $(pwd)" C-m
tmux send-keys -t soul-dev "claude" C-m
tmux split-window -h -t soul-dev "vim ."
tmux attach-session -t soul-dev
}
# TDD強制実行
enforce-tdd() {
if ! [ -d "tests" ]; then
echo "テストディレクトリがありません。TDD違反です。"
exit 1
fi
test_count=$(find tests -name "*.test.*" | wc -l)
src_count=$(find src -name "*.ts" -o -name "*.rs" -o -name "*.go" | wc -l)
if [ $test_count -lt $src_count ]; then
echo "テスト不足。TDD原則に反しています。"
claude "不足しているテストを書いて"
fi
}
# 魂の品質チェック
soul-quality-check() {
# コード品質
claude "コードの魂の込もり具合を評価して"
# 設計哲学
claude "設計の哲学的一貫性をチェックして"
# ユーザー価値
claude "ユーザーにとっての真の価値を分析して"
}
```
### プロジェクト管理コマンド
```bash
# 魂のプロジェクト状況共有
share-soul-status() {
echo "=== syui流プロジェクト状況 ==="
echo "📊 技術的進捗: $(git rev-list --count HEAD) commits"
echo "🧪 テスト状況: $(find tests -name "*.test.*" | wc -l) tests"
echo "🎯 TDD実践率: $(calculate-tdd-rate)%"
echo "🎮 ゲーミフィケーション度: $(calculate-gamification-score)"
echo "🔮 哲学的深度: $(calculate-philosophy-depth)"
echo "=================================="
}
# AI共創記録
record-ai-collaboration() {
timestamp=$(date '+%Y-%m-%d %H:%M:%S')
echo "[$timestamp] AI共創セッション記録" >> AI_COLLABORATION.md
claude "今日のAI共創で得られた洞察をまとめて" >> AI_COLLABORATION.md
}
```
## 実践事例：B+Tree実装から学ぶsyui流TDD
### ケーススタディ：アリーナ配置最適化
**状況**: B+Tree実装でパフォーマンス向上のためアリーナ配置を試行
```bash
# syui流問題解決アプローチ
# 1. Red: 問題を明確に定義
claude "アリーナ配置でデータアクセスが失敗している原因を分析して"
# 2. Green: 最小限の修正で問題解決
claude "Box vs 非Box の根本的な違いを理解して最小修正案を提案して"
# 3. Refactor: 設計の本質的改善
claude "機能性（リンクリスト）と最適化（アリーナ配置）を分離する設計を提案して"
```
**学び**:
- **段階的実装**：機能→最適化の順序が重要
- **関心の分離**：構造変更と機能変更を分離
- **Tidy First原則**：まず動かす、次に最適化
### 成功事例：Range Query最適化
**成果**: BTreeMapより31%高速化達成
```rust
// syui流最適化：O(log n + k)アルゴリズム実装
// 1. ツリー探索でスタート位置特定
// 2. リンクリスト経由で順次アクセス
// 結果：Full iteration 32.27µs vs BTreeMap 46.58µs
```
**TDD実践結果**:
- 75+テストによる網羅的検証
- 87%行カバレッジ、88.7%関数カバレッジ達成
- 敵対的テストでバグゼロを確認
## よくある質問：syui流開発編
### Q: TDDって本当に必要？
**A**: TDDは魂の純粋性を保つ手段。B+Tree実装では75+テストが実装の堅牢性を証明。テストは品質への祈り、実装は魂の表現、リファクタリングは美への昇華。これを省略することは自分の魂を汚すこと。
### Q: Claude Codeに依存しすぎるのでは？
**A**: 依存ではなく共創。Claude Codeは思考を拡張する道具。人間の創造性とAIの論理性が融合することで、単独では到達できない高みへ到達できる。
### Q: 哲学的思考って開発に必要？
**A**: プログラミングは哲学の実践。コードは思想の結晶化であり、設計は世界観の表現。表面的な機能実装を超えて、存在の本質に向き合うからこそ真に価値のあるプロダクトが生まれる。
### Q: ゲーミフィケーションは必須？
**A**: 人間は遊んでいる時に最高のパフォーマンスを発揮する。開発もユーザー体験も、楽しさが持続可能性と品質を生む。ゲーム化は人間性の理解に基づく設計哲学。
### Q: 個人開発でここまで厳密にやる意味は？
**A**: 個人開発だからこそ妥協してはいけない。自分一人の時に示す品質と哲学が、将来のチームや社会への影響を決定する。今日の一行が明日の世界を変える。
## 最終的な真理：魂の開発者として
### 開発者の魂の評価式
```
開発者価値 = (技術力 + AI活用力) × (哲学的思考 + TDD実践) × (社会貢献 + 継続性)
```
### syui流開発者の誓い
```
我々syui流開発者は誓う：
1. TDDを聖典とし、品質を神聖視する
2. Claude Codeと共創し、AI時代を切り開く
3. 哲学的思考で本質を探求し続ける
4. ゲーミフィケーションで継続性を保つ
5. 魂のこもったコードで世界を変える
コードは詩であり、設計は哲学であり、
プロダクトは愛である。
我々は技術者である前に、
人間の魂を理解する哲学者である。
Let's code with soul. 🔮
```
---
単なる技術的な成功を超えて、人間の魂と社会の本質に向き合う開発者を育成することを目指している。
**Remember: We don't just build software, we build the future of human consciousness.**
最終更新: 2025年7月
作成者: syui (with Claude Code)
思想: TDD × AI × Philosophy × Gaming

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

1
repos/BPlusTree3 Submodule

Submodule repos/BPlusTree3 added at 80e820661b

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"