# macOS (Homebrew)
$ brew install jj
 
# macOS (MacPorts)
$ sudo port install jujutsu
 
# Linux (cargo)
$ cargo install --locked jujutsu-cli
 
# Linux (Arch Linux)
$ pacman -S jujutsu
 
# Linux (Nix)
$ nix-env -iA nixpkgs.jujutsu
 
# Linux (Ubuntu/Debian - snap)
$ snap install jj-vcs
 
# Windows (Scoop)
$ scoop install jujutsu
 
# Windows (Chocolatey)
$ choco install jujutsu
 
# Windows (winget)
$ winget install martinvonz.jj
 
# ソースからビルド
$ git clone https://github.com/martinvonz/jj.git
$ cd jj
$ cargo build --release
$ cp target/release/jj ~/.local/bin/
 
# バージョン確認
$ jj version
jj 0.25.0

# ユーザー名とメールアドレス（必須）
$ jj config set --user user.name "Gaku"
$ jj config set --user user.email "gaku@example.com"
 
# エディタの設定
$ jj config set --user ui.editor "vim"
# VS Code を使う場合
$ jj config set --user ui.editor "code --wait"
# Emacs を使う場合
$ jj config set --user ui.editor "emacs -nw"
 
# diff エディタの設定（split, squash で使用）
$ jj config set --user ui.diff-editor "meld"
# difftastic を使う場合
$ jj config set --user ui.diff.tool "difft"
 
# ページャーの設定
$ jj config set --user ui.pager "less -FRX"
# delta を使う場合
$ jj config set --user ui.pager "delta"
 
# デフォルトコマンドの設定（引数なしで jj を実行した時のコマンド）
$ jj config set --user ui.default-command "log"
 
# 設定の確認
$ jj config list
$ jj config list --user    # ユーザーレベルの設定のみ
 
# 設定ファイルのパスを確認
$ jj config path --user
# → ~/.jjconfig.toml

# ~/.jjconfig.toml の全体像
 
[user]
name = "Gaku"
email = "gaku@example.com"
 
[ui]
editor = "vim"
diff-editor = "meld"
merge-editor = "meld"
pager = "less -FRX"
default-command = "log"
# カラー出力の制御
color = "auto"  # "always", "never", "auto"
# ページャーを使うかどうか
paginate = "auto"  # "auto", "never"
 
[git]
# push時のブックマーク名プレフィックス
push-bookmark-prefix = "gaku/push-"
# fetch時に自動的にGitのタグをインポート
auto-local-bookmark = false
 
[aliases]
# よく使うコマンドのエイリアス
l = ["log", "-r", "ancestors(heads(all()), 10)"]
ll = ["log", "--no-graph"]
d = ["diff"]
ds = ["diff", "--stat"]
s = ["status"]
n = ["new"]
c = ["commit"]
desc = ["describe"]

# Bash
$ jj util completion bash > ~/.local/share/bash-completion/completions/jj
# または
$ echo 'source <(jj util completion bash)' >> ~/.bashrc
 
# Zsh
$ jj util completion zsh > ~/.zfunc/_jj
# .zshrc に以下を追加:
# fpath=(~/.zfunc $fpath)
# autoload -Uz compinit && compinit
 
# Fish
$ jj util completion fish > ~/.config/fish/completions/jj.fish
 
# PowerShell
$ jj util completion powershell | Out-File -FilePath $PROFILE -Append

# difftasticのインストール
$ brew install difftastic   # macOS
$ cargo install difftastic  # cargo
 
# jjconfig.toml での設定
# [ui]
# diff.tool = ["difft", "--color=always", "$left", "$right"]
 
# コマンドラインでの一時的な使用
$ jj diff --tool difft
$ jj log -p --tool difft

# スナップショッティングの確認
$ echo "Hello" > hello.txt
$ echo "World" > world.txt
 
# この時点ではまだcommitに反映されていない（ファイルシステム上のみ）
 
# jj status を実行するとスナップショットが取得される
$ jj status
Working copy changes:
A hello.txt
A world.txt
 
# 以降、jjコマンドの出力には常に最新のファイル状態が反映される

# watchmanのインストール
$ brew install watchman   # macOS
$ sudo apt install watchman  # Ubuntu
 
# jjの設定でwatchmanを有効化
$ jj config set --user core.fsmonitor "watchman"
 
# watchmanが有効な場合の動作:
# - ファイルシステムの変更を常時監視
# - スナップショット時に変更されたファイルのみチェック
# - 大規模リポジトリ（10万ファイル超）でも数百msで完了

# 新規リポジトリの作成
$ jj git init my-project
$ cd my-project
 
# 既存のGitリポジトリをjjで使う（co-located）
$ cd existing-git-repo
$ jj git init --colocate
# → .jj/ ディレクトリが作成され、既存の .git/ と共存
 
# リモートリポジトリのクローン
$ jj git clone https://github.com/user/repo.git
$ jj git clone git@github.com:user/repo.git  # SSH
 
# 特定のブランチのみクローン
$ jj git clone --branch main https://github.com/user/repo.git
 
# co-located でクローン（推奨）
$ jj git clone --colocate https://github.com/user/repo.git

# ファイルを作成・編集（自動的にworking copy commitに反映）
$ echo "Hello" > hello.txt
 
# 現在の状態を確認
$ jj status
Working copy changes:
A hello.txt
 
# working copy commitに説明を追加
$ jj describe -m "feat: hello.txtを作成"
 
# 複数行のメッセージを設定
$ jj describe -m "feat: hello.txtを作成
 
初期のHelloメッセージファイルを追加した。
このファイルはプロジェクトの基盤となる。"
 
# エディタで説明を編集（-m を省略）
$ jj describe
# → 設定されたエディタが開き、コミットメッセージを編集
 
# 新しいcommitを開始（現在の変更を確定し、新しい空commitへ移動）
$ jj new
# → 今の変更が確定され、その上に新しい空のworking copy commitが作成される
 
# describeとnewを同時に行うショートカット
$ jj commit -m "feat: hello.txtを作成"
# → jj describe -m "..." && jj new と同等
 
# ログの確認
$ jj log
@  rlvkpntz gaku@example.com 2025-02-11 15:30:00 abc12345
│  (empty) (no description set)
○  qpvuntsm gaku@example.com 2025-02-11 15:25:00 def67890
│  feat: hello.txtを作成
○  zzzzzzzz root() 00000000

# ログの表示オプション
 
# グラフなしで表示
$ jj log --no-graph
 
# 特定のrevision範囲を表示
$ jj log -r 'main..'
 
# パッチ（差分）付きで表示
$ jj log -p
 
# stat（変更ファイル統計）付きで表示
$ jj log -s
 
# カスタムテンプレートで表示
$ jj log -T 'change_id.short() ++ " " ++ description.first_line() ++ "\n"'
 
# 特定のファイルに関連するログのみ表示
$ jj log -r 'file("src/auth.js")'
 
# 直近N件のみ表示
$ jj log -n 10
# または revset で
$ jj log -r 'ancestors(@, 10)'

# working copyの変更を確認
$ jj diff
 
# 特定のchangeの変更を確認
$ jj diff -r qpvuntsm
 
# 2つのrevision間の差分
$ jj diff --from main --to @
 
# stat形式で概要を確認
$ jj diff --stat
 
# 特定のファイルのみ
$ jj diff src/auth.js
 
# サマリー形式（追加/変更/削除のファイル一覧）
$ jj diff --summary
 
# difftasticを使った差分表示
$ jj diff --tool difft
 
# 特定のrevisionの内容を詳細に表示
$ jj show qpvuntsm
$ jj show @-
$ jj show main

# .gitignore と同じ仕組み（Jujutsuは.gitignoreを読む）
$ echo "node_modules/" >> .gitignore
$ echo "*.log" >> .gitignore
$ echo ".env" >> .gitignore
 
# 特定ファイルを復元（working copyの変更を取り消す）
$ jj restore --from @- src/auth.js
# @- = working copyの親commit
 
# 特定のrevisionからファイルを復元
$ jj restore --from main src/config.js
 
# 全変更を取り消す
$ jj restore
 
# 特定のファイルパターンのみ復元
$ jj restore "src/**/*.js"
 
# ファイル一覧の確認
$ jj file list
$ jj file list -r main  # 特定revisionのファイル一覧

# ファイルの内容を特定のrevisionから表示
$ jj file show src/auth.js
$ jj file show -r main src/auth.js
 
# 特定のファイルの変更履歴を追跡
$ jj log -r 'file("src/auth.js")'
 
# ファイルのコピー・リネームの扱い
# Jujutsuはコピー/リネームを自動検出する
$ mv src/old.js src/new.js
$ jj status
# Working copy changes:
# R {src/old.js => src/new.js}
 
# 複数ファイルの一括操作
$ jj restore --from @- "src/*.js" "test/*.js"

# コンフリクトが発生してもrebaseは完了する
$ jj rebase -d main
# Rebased 3 commits
# New conflicts in:
#   rlvkpntz abc12345
 
# コンフリクト状態のログ
$ jj log
@  rlvkpntz gaku@... 2025-02-11 abc12345 conflict
│  feat: 認証機能                         ^^^^^^^^
│                                         コンフリクトマーク
○  ...
 
# コンフリクトを確認
$ jj status
Working copy changes:
C src/auth.js    ← C = conflict
 
# ファイルを編集してコンフリクトを解決
$ vim src/auth.js
# → 通常のファイル編集でコンフリクトマーカーを解消
# → 自動的にworking copy commitに反映
# → コンフリクトが解消されると conflict マークが消える

# コンフリクトの確認と解決の流れ
$ jj status
# C src/auth.js
 
# コンフリクトファイルの中身を確認
$ cat src/auth.js
# <<<<<<< Conflict 1 of 1
# %%%%%%% Changes from base to side #1
# -const AUTH_KEY = "old-key";
# +const AUTH_KEY = "new-key-from-branch-a";
# +++++++ Contents of side #2
# const AUTH_KEY = "new-key-from-branch-b";
# >>>>>>> Conflict 1 of 1 ends
 
# エディタでコンフリクトマーカーを削除して解決
$ vim src/auth.js
# const AUTH_KEY = "new-key-from-branch-b"; と書き換え
 
# 解決されたか確認
$ jj status
# Working copy changes:
# M src/auth.js    ← C(conflict) から M(modified) に変わった

# コンフリクトがあるcommitの上で作業を続行できる
$ jj log
@  rlvkpntz ... conflict
│  feat: 認証機能
○  ...
 
# コンフリクトを今は無視して、新しい作業を開始
$ jj new main
$ vim src/other-feature.js
$ jj describe -m "feat: 別の機能"
 
# 後からコンフリクトを解決
$ jj edit rlvkpntz
$ vim src/auth.js   # コンフリクトを解決
$ jj new            # 解決を確定
 
# コンフリクトのあるcommitを一覧
$ jj log -r 'conflict()'

# 操作ログの確認
$ jj op log
@  abc12345 gaku@... 2025-02-11 15:30:00
│  new empty commit
○  def67890 gaku@... 2025-02-11 15:25:00
│  describe commit rlvkpntz
○  789abcde gaku@... 2025-02-11 15:20:00
│  snapshot working copy
○  fedcba98 gaku@... 2025-02-11 15:15:00
│  add workspace 'default'
 
# 直前の操作を取り消す
$ jj undo
# → 直前のjjコマンドの効果が完全に取り消される
 
# 特定の操作時点に戻る
$ jj op restore def67890

# 間違ったrebaseを取り消す
$ jj rebase -d wrong-branch
# → しまった、間違ったブランチにrebaseしてしまった！
$ jj undo
# → rebase前の状態に完全に戻る
 
# abandonしたcommitを復活させる
$ jj abandon rlvkpntz
# → しまった、間違ったcommitをabandonしてしまった！
$ jj undo
# → commitが復活する
 
# 特定の操作時点のログを確認
$ jj op log --no-graph
# → 全操作の一覧が表示される
 
# 操作ログの差分を確認
$ jj op diff --from abc12345 --to def67890
# → 2つの操作間でどのcommitが変更されたかを表示
 
# 操作ログの詳細表示
$ jj op show abc12345

# change IDの形式
# - 英小文字のみ（a-z）で構成
# - 内部的には128ビットのランダム値
# - 表示時に短縮形を使用（ユニークな最短プレフィックス）
 
# change IDの確認
$ jj log -T 'change_id ++ "\n"'
# → rlvkpntzsqkxyrmpqvlwxpsmkowkzmkqtlqnovpv
# 表示上は rlvkpntz のように短縮される
 
# change IDでの参照
$ jj show rlvkpntz
$ jj show rlvk       # 十分にユニークなら短いプレフィックスでもOK
$ jj diff -r rl      # さらに短くても、ユニークなら動作する

# immutableなcommit = rebase, edit, squash等の対象にならないcommit
# デフォルトでは trunk()（main/master）以前のcommitがimmutable
 
# immutableの定義を確認
$ jj config get revset-aliases.'immutable_heads()'
# → "trunk() | tags()"
 
# immutableを変更（例: main と release タグ）
# ~/.jjconfig.toml に追加:
# [revset-aliases]
# 'immutable_heads()' = 'trunk() | tags() | remote_bookmarks()'
 
# immutableなcommitを編集しようとするとエラー
$ jj edit main
# Error: Commit abc12345 is immutable
# Hint: Configure the set of immutable commits via `revset-aliases.immutable_heads()`
 
# 一時的にimmutableを無視（非推奨だが緊急時に使用）
$ jj rebase -r main --ignore-immutable -d @

# 1. 最新のmainから作業開始
$ jj git fetch
$ jj new main@origin
 
# 2. ファイルを編集
$ vim src/feature.js
 
# 3. コミットメッセージを設定
$ jj describe -m "feat: ユーザープロフィール機能を追加"
 
# 4. さらに編集を続ける（自動的にcommitに反映）
$ vim src/feature.test.js
$ vim src/types.ts
 
# 5. 区切りがついたら新しいcommitを開始
$ jj new
 
# 6. 次の機能の実装
$ vim src/another-feature.js
$ jj describe -m "feat: 通知機能を追加"
 
# 7. pushする前にブックマークを設定
$ jj bookmark create feature-profile -r @-  # プロフィール機能のcommit
$ jj bookmark create feature-notify -r @    # 通知機能のcommit
 
# 8. pushしてPRを作成
$ jj git push --bookmark feature-profile --allow-new
$ jj git push --bookmark feature-notify --allow-new

# 2つ前のcommitにタイポを見つけた場合
 
# 方法1: jj edit で直接編集
$ jj edit rlvkpntz           # 修正したいcommitに移動
$ vim src/feature.js          # ファイルを修正
$ jj new                     # 新しいworking copyに戻る
# → 間のcommitは自動リベース
 
# 方法2: working copyで修正してabsorbで振り分け
$ vim src/feature.js          # working copyで修正
$ jj absorb                  # 修正を元のcommitに自動振り分け
 
# 方法3: working copyで修正してsquashで統合
$ vim src/feature.js          # working copyで修正
$ jj squash --into rlvkpntz  # 特定のcommitに統合

# 認証機能の開発中に緊急バグ修正が入った場合
 
# 現在の作業状態
$ jj log
@  xxx  feat: 認証機能の実装中
○  main ...
 
# 緊急バグ修正のために新しいcommitを作成（mainから分岐）
$ jj new main
$ vim src/bugfix.js
$ jj describe -m "fix: ログインエラーの修正"
$ jj bookmark create hotfix -r @
$ jj git push --bookmark hotfix --allow-new
 
# 元の作業に戻る
$ jj edit xxx    # 認証機能のcommitに戻る
# → stash不要！全てがcommitとして保存されている

# NG: Jujutsuでgit addは不要
$ vim src/auth.js
$ git add src/auth.js        # ← 不要！
$ jj describe -m "fix: auth"
 
# OK: ファイルを編集するだけで自動反映
$ vim src/auth.js
$ jj describe -m "fix: auth"
# → working copy commitに自動的に反映されている

# NG: describe後にnewせず作業を続ける
$ jj describe -m "feat: ユーザー認証"
$ vim src/api.js       # ← この変更も "feat: ユーザー認証" に入ってしまう
 
# OK: 新しい論理的変更の前にjj newする
$ jj describe -m "feat: ユーザー認証"
$ jj new               # ← 新しいcommitを開始
$ vim src/api.js       # → 新しいcommitに記録される
$ jj describe -m "feat: APIエンドポイント"

# NG: commit ID（SHA-1）で参照し続ける
$ jj edit abc12345
$ vim src/fix.js
$ jj new
# → abc12345 はもう存在しない（rebaseでSHAが変わった）
 
# OK: change IDで参照する
$ jj edit rlvkpntz
$ vim src/fix.js
$ jj new
# → rlvkpntz は rebase 後も変わらない

# 注意: jj undoは直前の「1つの」jj操作のみ取り消す
$ jj rebase -d main
$ jj describe -m "new message"
$ jj undo
# → describe のみが取り消される（rebaseは取り消されない）
 
# 複数操作を戻したい場合は jj op restore を使う
$ jj op log
# → 戻りたい時点のoperation IDを確認
$ jj op restore <op-id>

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

$ cd existing-git-repo
$ jj git init --colocate
# → .jj/ が作成され、既存の .git/ と共存
# → jj log で既存の全コミット履歴が表示される
# → git コマンドもそのまま使える
 
# 気に入らなければ .jj/ を削除するだけで元に戻せる
$ rm -rf .jj
# → 完全にGitのみの状態に戻る