# Step 1: 既存のGitリポジトリでJujutsuを初期化
$ cd my-git-project
$ jj git init --colocate
Initialized repo in "."
 
# Step 2: 状態の確認
$ jj log
@  rlvkpntz gaku@example.com 2025-02-11 abc12345
│  (empty) (no description set)
○  qpvuntsm gaku@example.com 2025-02-10 def67890
│  feat: latest commit
◆  zzzzzzzz root() 00000000
 
# Step 3: .gitignoreにjjのファイルを追加（通常は不要、.jjは自動でignore）
 
# Step 4: 設定の確認
$ jj config list
# → user.name, user.email等が表示される
 
# Gitの設定からユーザー情報を自動取得
# → git config のuser.name/emailがデフォルトで使われる

# 方法1: jjで新規作成（co-located）
$ jj git init --colocate my-project
$ cd my-project
 
# 方法2: git cloneしてからjjを追加
$ git clone https://github.com/user/repo.git
$ cd repo
$ jj git init --colocate
 
# 方法3: jj git clone（自動的にco-located）
$ jj git clone https://github.com/user/repo.git
$ cd repo
# → .git/ と .jj/ の両方が存在する
 
# 方法4: jjのみのリポジトリ（co-locatedではない）
$ jj git init my-project
$ cd my-project
# → .jj/ のみ、.git/ は .jj/repo/store/git/ 内に隠蔽
# → git コマンドは使えない（推奨しない移行時は）

# gitコマンドを使った後にjjの状態を同期
$ git fetch origin
$ jj git import        # git→jj のref同期（通常は自動）
 
# jjコマンドを使った後にgitの状態を同期
$ jj git export        # jj→git のref同期（通常は自動）
 
# 同期の確認
$ jj git import && jj git export

# 安全に使えるGitコマンド（jjとの不整合が起きにくい）
$ git status           # 状態確認（読み取り専用）
$ git log              # ログ確認（読み取り専用）
$ git diff             # 差分確認（読み取り専用）
$ git blame            # blame確認（読み取り専用）
$ git bisect           # bisect（読み取り専用の調査）
$ git grep             # ファイル内検索（読み取り専用）
$ git fetch            # fetch（jjが自動importする）
$ git stash            # stash（jjからは見えない）
$ git tag              # タグ作成（jjが自動importする）
 
# 注意が必要なGitコマンド（jjのOperation Logと不整合の可能性）
$ git commit           # → jj commit を推奨
$ git rebase           # → jj rebase を推奨
$ git merge            # → jj new @ BRANCH を推奨
$ git reset            # → jj abandon / jj undo を推奨
$ git checkout -b      # → jj new + jj bookmark create を推奨
$ git push --force     # → jj git push を推奨

# 既存プロジェクトにco-locatedで導入
$ cd my-project
$ jj git init --colocate
 
# 日常作業をjjで行ってみる
$ jj new main
$ vim src/feature.js
$ jj describe -m "feat: 新機能"
$ jj new
$ jj git push --bookmark feature --allow-new

# jj edit による過去commit の直接編集
$ jj edit <change-id>
$ vim src/auth.js
$ jj new
 
# jj squash / jj split によるcommit整理
$ jj squash
$ jj split src/auth.js src/api.js
 
# revset クエリの活用
$ jj log -r 'mine() & (main..)'
 
# jj absorb の活用
$ jj absorb
 
# スタックドPRの作成
$ jj new main
$ vim src/types.ts
$ jj describe -m "feat: types"
$ jj bookmark create pr/types -r @
$ jj new
$ vim src/auth.ts
$ jj describe -m "feat: auth"
$ jj bookmark create pr/auth -r @
$ jj git push --bookmark pr/types --allow-new
$ jj git push --bookmark pr/auth --allow-new

# チーム共有の設定ファイル
# .jj/repo/config.toml (リポジトリレベル設定)
[revset-aliases]
'immutable_heads()' = 'trunk() | tags()'

# チーム共有の.jj/repo/config.toml
[revset-aliases]
# 保護するcommit
'immutable_heads()' = 'trunk() | tags() | bookmarks("release-")'
 
# よく使うrevset
'unpushed()' = 'mine() ~ ::remote_bookmarks()'
'review_ready()' = 'bookmarks() & mine() ~ empty() ~ conflict()'
'stale()' = 'bookmarks() & committer_date(before:"30 days ago")'

# チーム運用のベストプラクティス
 
# 1. ブックマーク命名規則
$ jj bookmark create feature/AUTH-123-login -r @
$ jj bookmark create fix/BUG-456-null-check -r @
$ jj bookmark create chore/update-deps -r @
 
# 2. コミットメッセージ規則（Conventional Commits）
$ jj describe -m "feat(auth): ログイン機能を追加
 
Refs: AUTH-123"
 
# 3. PRの作成フロー
$ jj git push --bookmark feature/AUTH-123-login --allow-new
# → GitHub CLIでPR作成
$ gh pr create --base main --head feature/AUTH-123-login
 
# 4. PRマージ後のクリーンアップ
$ jj git fetch
$ jj bookmark delete feature/AUTH-123-login
$ jj git push --deleted

# Git:
$ git checkout -b feature/auth main
$ vim src/auth.js
$ git add . && git commit -m "feat: 認証"
$ git push -u origin feature/auth
# PRを作成
 
# Jujutsu:
$ jj new main
$ vim src/auth.js
$ jj describe -m "feat: 認証"
$ jj bookmark create feature/auth -r @
$ jj git push --bookmark feature/auth --allow-new
# PRを作成（GitHub CLIまたはWeb UI）
 
# レビュー指摘への対応（Git）:
$ git checkout feature/auth
$ vim src/auth.js
$ git add . && git commit -m "fix: レビュー指摘対応"
$ git push
 
# レビュー指摘への対応（Jujutsu）:
$ jj edit feature/auth      # 元のcommitを直接編集
$ vim src/auth.js            # 修正
$ jj git push --bookmark feature/auth  # 更新（force push相当が自動）
# → コミット履歴がクリーンに保たれる

# Git:
$ git fetch origin
$ git checkout feature/auth
$ git rebase origin/main
# コンフリクト解決...
$ git add .
$ git rebase --continue
# さらにコンフリクト解決...
$ git push --force-with-lease
 
# Jujutsu:
$ jj git fetch
$ jj rebase -d main@origin
# コンフリクトがあればcommitに記録（後で解決可）
$ jj resolve          # マージツールで解決
$ jj git push --bookmark feature/auth
# → force push相当が自動的に行われる
 
# コンフリクト解決の違い
# Git: rebase中にコンフリクトが発生すると中途半端な状態になる
#      → git rebase --abort で中断するか、解決して --continue
# jj: コンフリクトはcommitに記録されるので、いつでも解決可能
#     → 中途半端な状態にならない
#     → 他の作業をしてから後で解決することも可能

# Git: 直前のcommitを修正
$ git commit --amend -m "fix: corrected message"
 
# Git: 3つ前のcommitを修正
$ git rebase -i HEAD~3
# → pick → edit に変更
# → 修正
$ git commit --amend
$ git rebase --continue
 
# Jujutsu: 直前のcommitを修正（メッセージ）
$ jj describe -m "fix: corrected message"
 
# Jujutsu: 任意のcommitを修正（内容）
$ jj edit <change-id>
$ vim src/auth.js
# → 保存するだけ、自動的にcommitに反映
# → 子commitが自動リベース（コンフリクトがあれば記録）
$ jj new   # working copyを先端に戻す
 
# Jujutsu: 修正をabsorbで自動振り分け
$ vim src/auth.js   # 修正
$ vim src/api.js    # 修正
$ jj absorb
# → 各行の修正が元のcommitに自動振り分け

# Git:
$ git stash
$ git checkout another-branch
$ ... 作業 ...
$ git checkout original-branch
$ git stash pop
 
# Jujutsu:
# stashは不要 — 全てがcommitとして保存される
 
# 現在の作業にメモを付けて別の作業へ
$ jj describe -m "wip: ログイン画面の途中"
$ jj new main          # mainの上で新しい作業を開始
$ ... 作業 ...
$ jj edit <元のchange-id>  # 元の作業に戻る
# → stashは不要、全てがcommitとして保存されている
 
# 複数の「stash」を同時に管理
$ jj log -r 'description(regex:"^wip:")'
# → wip:で始まるcommitを一覧表示
# → jj edit で任意の作業に戻れる

# Git: git rebase -i HEAD~4
# pick abc Fix A
# squash def Fix B (Aに統合)
# pick ghi Feature C
# drop jkl Remove D
 
# Jujutsu: 個別の操作に分解
$ jj squash --from def --into abc    # BをAに統合
$ jj abandon jkl                      # Dを削除
# → 自動リベースで残りが整列
 
# Git: reorder commits
# git rebase -i → 行を並べ替え
 
# Jujutsu:
$ jj rebase -r ghi -d abc            # ghiをabcの直後に移動
# → 他のcommitは自動リベース
 
# Git: split a commit
# git rebase -i → edit → git reset HEAD~ → git add -p → git commit → git rebase --continue
 
# Jujutsu:
$ jj split -r <change-id>
# → 対話的に分割（1コマンドで完結）

# Gitflow: develop → feature → develop → release → main
 
# Jujutsuでのマッピング:
# develop = develop ブックマーク
# feature = 個別のcommit/ブックマーク
 
# feature ブランチ開始
$ jj new develop
$ jj bookmark create feature/login -r @
 
# feature 作業
$ vim src/login.tsx
$ jj describe -m "feat: ログイン画面"
 
# develop にマージ
$ jj new develop feature/login    # マージcommitを作成
$ jj describe -m "merge: feature/login into develop"
$ jj bookmark set develop -r @
 
# release ブランチ
$ jj new develop
$ jj bookmark create release/1.0 -r @
 
# hotfix
$ jj new main
$ jj bookmark create hotfix/critical-fix -r @
$ vim src/fix.js
$ jj describe -m "hotfix: クリティカルな修正"
 
# mainとdevelopにマージ
$ jj new main hotfix/critical-fix
$ jj bookmark set main -r @
$ jj new develop hotfix/critical-fix
$ jj bookmark set develop -r @

# Trunk-Based: mainに直接（短寿命ブランチで）
 
# 短寿命の作業ブランチ
$ jj new main
$ vim src/feature.js
$ jj describe -m "feat: 小さな機能追加"
$ jj bookmark create small-feature -r @
$ jj git push --bookmark small-feature --allow-new
# → PRを作成、レビュー後すぐにマージ
 
# スタックドPRで大きな変更を分割
$ jj new main
$ jj describe -m "refactor: 型定義の整理"
$ jj bookmark create pr/1-types -r @
 
$ jj new
$ jj describe -m "feat: 新しいAPI"
$ jj bookmark create pr/2-api -r @
 
$ jj new
$ jj describe -m "feat: UIの更新"
$ jj bookmark create pr/3-ui -r @
 
# 各PRを順番にレビュー＆マージ
$ jj git push --bookmark pr/1-types --allow-new
$ jj git push --bookmark pr/2-api --allow-new
$ jj git push --bookmark pr/3-ui --allow-new

# 問題1: jj と git の状態が不整合になった
$ jj git import    # git→jj の同期を強制
$ jj git export    # jj→git の同期を強制
 
# 問題2: jj git push で認証エラー
$ jj git remote set-url origin git@github.com:user/repo.git  # SSH化
# または
$ gh auth setup-git  # GitHub CLI のトークンを設定
 
# 問題3: working copy が予期しない状態になった
$ jj op log         # 操作履歴を確認
$ jj undo           # 直前の操作を取り消し
$ jj op restore <op-id>  # 特定の時点に復元
 
# 問題4: .jjを完全に削除してGitだけに戻りたい
$ rm -rf .jj
$ git checkout .    # working copyをGitの状態に復元
 
# 問題5: jj git fetch でエラー
# "unexpected response from remote"
$ jj git remote set-url origin git@github.com:user/repo.git
# SSH鍵の問題:
$ ssh -T git@github.com  # SSH接続テスト
$ eval "$(ssh-agent -s)" && ssh-add ~/.ssh/id_ed25519
 
# 問題6: co-located repoでGitコマンドがworking copyを変更した
$ jj git import    # gitの変更をjjに取り込む
# それでも不整合な場合:
$ jj workspace update-stale   # working copyの状態を更新

# Git: rebase中のコンフリクト
$ git rebase main
# CONFLICT (content): Merge conflict in src/auth.js
# → 中途半端な状態（"rebase in progress"）
# → 解決してgit add → git rebase --continue
# → または git rebase --abort で中断
 
# Jujutsu: rebase時のコンフリクト
$ jj rebase -d main
# → コンフリクトはcommitに記録される
# → 中途半端な状態にはならない
# → jj status でコンフリクトの状態を確認
$ jj status
# Working copy changes:
# C src/auth.js  (conflict)
 
# コンフリクトの解決
$ jj resolve src/auth.js
# → マージツールが起動
# → 解決するとコンフリクトマーカーが消える
 
# または手動で解決
$ vim src/auth.js
# → コンフリクトマーカーを削除
# → 保存するだけでコンフリクトが解消される
 
# コンフリクトを含むcommitの上に作業を続けることも可能
# → 後で解決すればよい
$ jj new    # コンフリクトを放置して次の作業へ
$ ... 別の作業 ...
$ jj edit <conflict-commit>   # 後でコンフリクトを解決
$ vim src/auth.js

# 大規模リポジトリでのパフォーマンス
# 1. watchmanの有効化
$ jj config set --user core.watchman.register-snapshot-trigger true
 
# 2. fsmonitorの設定
$ jj config set --user core.fsmonitor "watchman"
 
# 3. デフォルトrevsetの制限
$ jj config set --user ui.default-revset 'ancestors(heads(all()), 10)'
# → ログ表示を最新10世代に制限
 
# 4. .gitignoreの最適化
# → 不要なファイル（node_modules, build/等）を確実にignore
# → jjのworking copy snapshotが高速化される
 
# 5. 大規模なバイナリファイル
# → Git LFS を使用（co-located repoでgit lfsコマンドを使用）
$ git lfs install
$ git lfs track "*.psd"

# co-located repoではVS CodeのGit統合がそのまま使える
# → Source Control パネルでdiff、commit、pushが可能
# → ただし、jjのworking copy概念と少しズレがある
 
# 推奨設定:
# 1. VS CodeのTerminalでjjコマンドを使用
# 2. Source Control パネルはdiff確認用として使用
# 3. commit/pushはjjコマンドで実行
 
# VS Code拡張（存在する場合）
# → "Jujutsu" 拡張を検索してインストール
 
# settings.json
{
  "git.enabled": true,
  "git.autofetch": true,
  // jjのworking copyと競合しないよう設定
  "git.autoStash": false,
  "git.confirmSync": true
}

# co-located repoではIntelliJのGit統合がそのまま使える
# → Version Control ツールウィンドウでdiff、log確認
# → ただしcommitはjjコマンドで行うのが安全
 
# 推奨設定:
# 1. IntelliJのTerminalでjjコマンドを使用
# 2. VCS操作はdiff/blame/log確認用として使用
# 3. commit/push/rebaseはjjコマンドで実行

# lazyjjのインストール
$ cargo install lazyjj
 
# 使用
$ lazyjj
# → lazygit風のTUIでjjの操作ができる
# → log表示、diff、describe、new、squash等が視覚的に操作可能
 
# キーバインド
# j/k: 上下移動
# Enter: 詳細表示
# d: diff表示
# n: jj new
# e: jj edit
# s: jj squash
# q: 終了

# === 朝一番の同期 ===
$ jj git fetch                    # リモートの最新を取得
$ jj rebase -d main@origin        # mainに追従
 
# === 新しい作業の開始 ===
$ jj new main                     # mainから新しい変更を開始
$ jj describe -m "feat: 機能名"   # メッセージを設定
 
# === ファイル編集中 ===
$ vim src/feature.ts               # 編集（自動的にcommitに反映）
$ jj status                        # 状態確認
$ jj diff                          # 差分確認
 
# === 変更の確定と次の作業 ===
$ jj describe -m "feat: 完成した機能" # メッセージ確定
$ jj new                           # 次のcommitに移動
 
# === PRの作成 ===
$ jj bookmark create feature-x -r @-  # 直前のcommitにブックマーク
$ jj git push --bookmark feature-x --allow-new
 
# === 過去のcommitを修正 ===
$ jj edit <change-id>              # 過去のcommitに移動
$ vim src/fix.ts                    # 修正
$ jj new                           # 先端に戻る
 
# === 操作の取り消し ===
$ jj undo                          # 直前の操作を取り消し
$ jj op log                        # 操作履歴を確認
$ jj op restore <op-id>            # 特定時点に復元

# NG: jjで作業した後にgit reset --hardする
$ jj new main
$ vim src/feature.js
$ jj describe -m "feat: new feature"
$ git reset --hard HEAD    # ← jjの変更が消失する可能性
# → jjのOperation Logと不整合が生じる
 
# OK: 一貫してjjコマンドを使う
$ jj undo                  # jjの操作取り消し
$ jj op restore <op-id>   # 特定時点への復元

# NG: "来週からJujutsu必須です"
# → 学習コストが高く、生産性が一時的に大幅低下
# → Gitに戻したい人のモチベーション低下
 
# OK: co-located repoで段階的に導入
# Phase 1: 興味のあるメンバーから試用
# Phase 2: 成功事例を共有
# Phase 3: 公式にサポートするが強制しない
# → GitユーザーとJujutsuユーザーが共存可能

# NG: stagingの概念を持ち込む
$ vim src/auth.ts
$ jj add src/auth.ts   # ← このコマンドは存在しない
 
# OK: jjにはstagingがないことを理解する
$ vim src/auth.ts
# → 保存するだけで自動的にworking copy commitに含まれる
# → 特定のファイルだけcommitしたい場合はjj split

# NG: 意図しない変更が含まれたままnew
$ vim src/auth.ts
$ vim src/unrelated.ts   # 関係ないファイルも編集してしまった
$ jj new                  # ← 両方の変更が前のcommitに含まれる
 
# OK: statusを確認してから次へ進む
$ jj status               # 変更内容を確認
$ jj diff                 # 差分を確認
# 不要な変更を取り消す
$ jj restore --from @- src/unrelated.ts
$ jj new                  # クリーンな状態で次へ

# NG: bookmarkなしでpush
$ jj new main
$ vim src/feature.ts
$ jj describe -m "feat: new feature"
$ jj git push             # ← pushするブックマークがない！
 
# OK: bookmarkを作成してからpush
$ jj bookmark create feature-x -r @
$ jj git push --bookmark feature-x --allow-new
 
# または --change で自動生成
$ jj git push --change @  # ← change IDからブックマーク名を自動生成

# NG: editしたまま作業を続ける
$ jj edit <old-change-id>    # 過去のcommitに移動
$ vim src/fix.ts              # 修正
$ vim src/new-feature.ts      # ← 新しい機能も追加（混在！）
 
# OK: 修正が終わったらjj newで先端に戻る
$ jj edit <old-change-id>    # 過去のcommitに移動
$ vim src/fix.ts              # 修正のみ
$ jj new                      # 先端に戻る
$ vim src/new-feature.ts      # 新しい機能は別のcommitで

# co-located repoの確認
$ ls -la .git/ .jj/
# → 両方が存在
$ git log --oneline -5
# → Gitの履歴がそのまま
$ jj log
# → 同じ履歴がjjからも見える

# JujutsuでPRを作成するフロー
$ jj new main
$ vim src/feature.js
$ jj describe -m "feat: new feature"
$ jj bookmark create feature-branch -r @
$ jj git push --bookmark feature-branch --allow-new
# → GitHubでPRを作成（通常のGitと全く同じ）
 
# GitHub CLIを使ったPR作成
$ gh pr create --base main --head feature-branch --title "feat: new feature"

# 混乱1: staging（git add）がない
# → ファイルを保存するだけで自動的にcommitに含まれる
# → 「特定のファイルだけcommitしたい」場合はjj split
 
# 混乱2: working copy = commit
# → Gitでは「未コミットの変更」が存在するが、jjでは常にcommitの上にいる
# → jj log で @ がworking copy commit
# → jj new で「次のcommitに移動」
 
# 混乱3: bookmark ≠ branch
# → Gitのbranchは「移動するポインタ」
# → jjのbookmarkも類似だが、自動追従はしない
# → commitを追加してもbookmarkは自動的に移動しない
# → jj bookmark set NAME -r @ で明示的に移動

# Jujutsuを完全に削除
$ rm -rf .jj
 
# Gitの状態を確認
$ git status
$ git log --oneline -5
# → Gitの履歴は完全に維持されている
 
# working copyの状態がおかしい場合
$ git checkout .
# → Gitの最新状態に復元

# バージョン確認
$ jj --version
 
# アップグレード
$ cargo install jj-cli
# または
$ brew upgrade jj
 
# アップグレード後の注意
# - .jj/repo/ のフォーマットが変わる場合がある
# - jjが自動的にマイグレーションを行う
# - 問題がある場合は jj op log で確認して jj undo

# watchmanの有効化（必須）
$ jj config set --user core.watchman.register-snapshot-trigger true
$ jj config set --user core.fsmonitor "watchman"
 
# revsetのデフォルトを制限
$ jj config set --user ui.default-revset 'ancestors(heads(all()), 10)'
 
# .gitignoreの最適化
# → node_modules, build, dist等を確実にignore
# → jjのsnapshot処理が高速化
 
# 注意: 数GBのリポジトリでも動作するが、
#       数十万ファイルの場合はwatchman必須

# gitを使うべきシーン（co-located repo）:
$ git blame src/auth.ts          # blameはgitで
$ git bisect start               # bisectはgitで
$ git grep "searchterm"           # ファイル内検索
$ git log -S "deleted_function"   # pickaxe検索
$ git stash                       # 一時退避（jjからは見えない）
$ git tag -a v1.0 -m "Release"    # アノテーションタグ
$ git lfs pull                    # LFSファイル取得
$ git submodule update             # サブモジュール更新
 
# jjを使うべきシーン:
$ jj new / jj describe / jj commit  # コミット操作
$ jj edit / jj squash / jj split    # 履歴の編集
$ jj rebase                          # リベース
$ jj absorb                          # 修正の自動振り分け
$ jj git push / jj git fetch         # リモート操作
$ jj undo / jj op restore            # 操作の取り消し
$ jj log -r '<revset>'              # 高度なログ検索