dirlens 1.0.10 → 1.0.11

package/README.md

@@ -133,19 +133,46 @@ Desktop/ (2 dirs, 2 files, 3.74 MB)
 - **JSON出力** — `--json` / `-J` で機械可読な構造データを出力
 - **HTMLレポート** — `--html` でブラウザで閲覧できる折りたたみツリーを生成
 - **クリップボードコピー** — `-C` で出力を自動コピー（ANSIコードを自動除去）
-- **AIモード** — `--ai` 一発で gitignore除外・日時・Markdown・クリップボードコピーを全適用
+- **AIチャット貼り付けモード** — `--ai` 一発で gitignore除外・日時・Markdown・クリップボードコピーを全適用（人間がコピペする用）
+- **エージェント解析モード** — `--agent` 一発で下記のAI/エージェント向け解析機能を全適用（クリップボードは使わない、自律実行しても安全）
 - **隠しファイル対応** — `-a` で表示切り替え
 - **サイズ順ソート** — `-s` で大きいものから表示
 
+### AI/エージェント向け解析機能（`--agent` でまとめて有効化）
+
+これらはAIチャットやコーディングエージェントがプロジェクト構造を理解する際に、ファイルの中身を逐一読まなくても済むよう設計された機能です。個別フラグでも使えます。
+
+- **トークン数概算** — `-T` でファイルごとの推定トークン数を表示（英数字記号は約4文字/トークン、日本語等は約1.5文字/トークンとして概算）
+- **git連携** — `-H` で各ファイルの最終コミット情報（メッセージ・相対日時）を表示。直近2000コミットまで走査
+- **TODO/FIXME抽出** — `-K` で `TODO`/`FIXME`/`HACK`/`XXX` コメントを抽出し、行番号付きで一覧表示
+- **テスト欠落検知** — `-V` で対応するテストファイルが見つからないソースファイルをマーク（命名規則ベースのヒューリスティック）
+- **エントリーポイント検出** — `-N` で `main.py`・`index.js`・`package.json` の `main`/`bin` フィールドなどから入口ファイルを推測してマーク
+- **シンボルアウトライン** — `-O` で関数・クラス名を簡易抽出（Python/JS/TS/Go/Rust対応、正規表現ベースのbest-effort）
+- **import/依存グラフ** — `-M` でファイル間のローカルなimport関係を解析し、`imports×N`（依存先数）・`used-by×N`（被参照数）を表示。Pythonは標準ライブラリの`ast`で正確に解析、他言語は正規表現＋パス解決
+
 ---
 
 ## 使い方
 
 ```bash
-# ── AI チャットへの貼り付け（最もよく使うコマンド）─────────────
+# ── AI チャットへの貼り付け（人間がコピペする用）──────────────
 dirlens --ai             # gitignore除外 + 日時 + Markdown + クリップボードコピー
 dirlens --ai -L 3        # 深さ指定と組み合わせ可
 
+# ── エージェント向け解析（自律実行向け・クリップボードは使わない）──
+dirlens --agent          # トークン数・git情報・TODO・テスト欠落・
+                          # エントリーポイント・アウトライン・import依存グラフを一括表示
+dirlens --agent --json   # 同上をJSON形式で（スクリプト/エージェント連携向け）
+
+# ── AI/エージェント向け解析（個別フラグ）────────────────────────
+dirlens -T                # ファイルごとの推定トークン数
+dirlens -H                # 最終コミット情報（要git）
+dirlens -K                # TODO/FIXME/HACK/XXXを抽出
+dirlens -V                # テストが無いソースファイルを表示
+dirlens -N                # エントリーポイントらしきファイルをマーク
+dirlens -O                # 関数・クラスの簡易アウトライン
+dirlens -M                # ローカルなimport/依存関係を解析
+
 # ── 表示制御 ──────────────────────────────────────────────────
 dirlens                  # カレントディレクトリ
 dirlens ~/Desktop        # 指定ディレクトリ
@@ -199,7 +226,8 @@ dirlens --no-color > dirlens.txt   # テキストファイルに書き出す
 | オプション           | 省略形        | 説明                                                        |
 |---------------------|--------------|-------------------------------------------------------------|
 | `path`              | —            | 対象ディレクトリ（省略時はカレント）                           |
-| **`--ai`**          | —            | **`-G --date -m -C` のショートカット。AIチャット用**          |
+| **`--ai`**          | —            | **`-G --date -m -C` のショートカット。人間がAIチャットに貼り付ける用** |
+| **`--agent`**       | —            | **`-G --date -T -H -K -V -N -O -M` のショートカット。エージェント向け解析（クリップボードは使わない）** |
 | `--depth N`         | `-L N`       | 表示する最大の深さ                                            |
 | `--all`             | `-a`         | 隠しファイル・ディレクトリも表示                               |
 | `-d`                | —            | ディレクトリのみ表示                                          |
@@ -224,6 +252,13 @@ dirlens --no-color > dirlens.txt   # テキストファイルに書き出す
 | `--max-size SIZE`   | —            | 指定サイズ以下のファイルのみ表示                               |
 | `--bar`             | —            | ディスク占有率バーを表示                                       |
 | `--emoji`           | —            | 拡張子に応じた絵文字アイコンを表示                             |
+| `--tokens`          | `-T`         | ファイルごとの推定トークン数を表示（概算）                      |
+| `--git`             | `-H`         | 最終コミット情報を表示（要git、直近2000コミットまで走査）        |
+| `--todo`            | `-K`         | TODO/FIXME/HACK/XXXコメントを抽出                             |
+| `--missing-tests`   | `-V`         | 対応するテストファイルが見つからないソースファイルを表示          |
+| `--entry`           | `-N`         | エントリーポイントらしきファイルを検出してマーク                 |
+| `--outline`         | `-O`         | 関数・クラスの簡易アウトラインを表示（正規表現ベース・対応言語限定）|
+| `--imports`         | `-M`         | ローカルなimport/依存関係を解析して表示（外部パッケージは対象外） |
 | `--markdown`        | `-m`         | Markdown コードブロック形式で出力（カラー自動無効）             |
 | `--json`            | `-J`         | JSON 形式で標準出力に出力                                     |
 | `--html [FILE]`     | —            | HTML レポートを生成（デフォルト: `dirlens.html`）              |
@@ -255,3 +290,21 @@ dirlens --no-color > dirlens.txt   # テキストファイルに書き出す
 - **ホームフォルダ（`~/`）やルート（`/`）で実行すると固まる場合があります** — サイズ計算は表示深さに関わらず底まで全再帰するため、`~/Library` や iCloud Drive など大容量ディレクトリで時間がかかります
 - **`-G` の否定パターン（`!`）** は対応していますが、ディレクトリを除外した後にその中のファイルを `!` で復活させることは非対応です（`*.log` + `!important.log` のようなファイル単位の否定は動作します）
 - `-p`（パーミッション）・`-u`（ユーザー名）・`-g`（グループ名）は macOS / Linux のみ対応（Windows では ID 番号を表示）
+
+### AI/エージェント向け解析機能の精度について
+
+dirlens は外部ライブラリに依存しない方針で作られているため、以下の機能は**完全な精度を保証しません**。重要な判断の根拠にする場合は、該当ファイルの中身を直接確認することを推奨します。
+
+| 機能 | 制限事項 |
+|---|---|
+| トークン数概算（`-T`） | 文字数ベースの大まかな目安。実際のトークナイザーとは一致しない |
+| シンボルアウトライン（`-O`） | 正規表現ベースの簡易抽出（ASTではない）。デコレータが複雑な場合や複数行にまたがる関数シグネチャは取得漏れすることがある。対応言語は Python・JS/TS・Go・Rust のみ |
+| import/依存グラフ（`-M`） | Pythonは標準ライブラリの `ast` で正確に解析されるため信頼度が高い。JS/TS/Go/Rustは正規表現＋パス解決のため、JS/TSのbare import（`react`等）・Rustの`self::`/`super::`・外部crate・モジュール外のGoパッケージは解決されず「external」扱いになる |
+| テスト欠落検知（`-V`） | ファイル命名規則のみで判定（`test_foo.py`等）。実際のテストカバレッジは見ていない。Rustは対象外（インラインテストの慣習のため検出不可） |
+| エントリーポイント検出（`-N`） | 既知のファイル名パターンと `package.json` の `main`/`bin` フィールドのみで判定 |
+| TODO/FIXME抽出（`-K`） | 単純な文字列マッチ。コメント外の文字列内に偶然該当語があっても拾われる場合がある |
+| git連携（`-H`） | 直近2000コミットのみ走査。それより古い変更しかないファイルは情報が出ない |
+
+### AIエージェントへの指示テンプレート
+
+エージェント（Claude Code・Cursor等）にプロジェクト探索の手順として `dirlens --agent` を使わせたい場合、`AGENT_RULE.md` のテンプレートを `CLAUDE.md`・`.cursorrules` 等のグローバルルールファイルにそのまま貼り付けて使えます。

package/dirlens.py

@@ -4,7 +4,7 @@ dirlens – ファイルサイズ付きディレクトリツリー表示ツー
 対応環境: macOS / Linux / Windows  (Python 3.8+)
 """
 
-import io, json, os, sys, stat as _stat, argparse, fnmatch, datetime, subprocess
+import io, json, os, sys, stat as _stat, argparse, fnmatch, datetime, subprocess, re, ast
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
@@ -26,7 +26,7 @@ def _enable_color():
 USE_COLOR = _enable_color()
 RESET = "\033[0m"; BOLD = "\033[1m"; DIM = "\033[2m"
 BLUE = "\033[34m"; CYAN = "\033[36m"; GREEN = "\033[32m"; MAGENTA = "\033[35m"
-RED = "\033[31m"
+RED = "\033[31m"; YELLOW = "\033[33m"
 
 def c(text, *codes):
     return ("".join(codes) + text + RESET) if USE_COLOR else text
@@ -43,7 +43,6 @@ def fmt_size(n, partial=False):
 
 def fmt_count(nd, nf, denied=False):
     sfx = "+" if denied else ""
-    # denied=True のとき数が不明なので複数形固定
     d_word = "dir"  if (nd == 1 and not denied) else "dirs"
     f_word = "file" if (nf == 1 and not denied) else "files"
     return f"{nd}{sfx} {d_word}, {nf}{sfx} {f_word}"
@@ -120,9 +119,8 @@ def copy_to_clipboard(text):
         return False
     except Exception: return False
 
-import re as _re
 def strip_ansi(text):
-    return _re.sub(r'\033\[[0-9;]*[mK]', '', text)
+    return re.sub(r'\033\[[0-9;]*[mK]', '', text)
 
 
 # ─── 絵文字 ───────────────────────────────────────────────────
@@ -247,6 +245,537 @@ def _prefetch_sizes(root_path):
         list(ex.map(dir_size, top))
 
 
+# ════════════════════════════════════════════════════════════
+# AI/エージェント向け解析機能
+# ════════════════════════════════════════════════════════════
+
+_BINARY_EXTS = {
+    ".png",".jpg",".jpeg",".gif",".bmp",".ico",".webp",
+    ".mp3",".mp4",".mov",".avi",".wav",".flac",".ogg",".webm",".mkv",
+    ".zip",".tar",".gz",".rar",".7z",".bz2",".xz",
+    ".pdf",".doc",".docx",".xls",".xlsx",".ppt",".pptx",
+    ".exe",".dll",".so",".dylib",".bin",".o",".a",".class",".jar",
+    ".woff",".woff2",".ttf",".otf",".eot",
+    ".db",".sqlite",".sqlite3",".pyc",".pyo",".whl",
+}
+
+def _is_probably_binary(name):
+    return os.path.splitext(name)[1].lower() in _BINARY_EXTS
+
+
+# --- トークン数概算（-T / --tokens） -------------------------
+def estimate_tokens(path, actual_size=None):
+    """テキストファイルのトークン数を概算する。バイナリ等は None。
+    あくまで大まかな目安（英数字記号は約4文字/トークン、それ以外（日本語等）は約1.5文字/トークンとして概算）。
+    """
+    SAMPLE_LIMIT = 2_000_000
+    try:
+        with open(path, "rb") as f:
+            data = f.read(SAMPLE_LIMIT + 1)
+    except OSError:
+        return None
+    truncated = len(data) > SAMPLE_LIMIT
+    if truncated:
+        data = data[:SAMPLE_LIMIT]
+    if b"\x00" in data[:8192]:
+        return None  # バイナリ判定
+    text = data.decode("utf-8", errors="ignore")
+    if not text:
+        return 0
+    ascii_chars = sum(1 for ch in text if ord(ch) < 128)
+    other_chars = len(text) - ascii_chars
+    tokens = ascii_chars / 4 + other_chars / 1.5
+    if truncated and actual_size and len(data) > 0:
+        tokens *= actual_size / len(data)
+    return max(1, round(tokens))
+
+def fmt_tokens(n):
+    if n is None: return None
+    if n >= 1000:
+        s = f"{n/1000:.1f}".rstrip("0").rstrip(".")
+        return f"~{s}K tok"
+    return f"~{n} tok"
+
+
+# --- git連携（-H / --git） ------------------------------------
+def load_git_log(root, max_commits=2000):
+    """直近コミット履歴から各ファイルの最終更新コミット情報を取得する。
+    gitが無い／リポジトリでない場合は空dictを返す（エラーにはしない）。
+    パフォーマンスのため履歴は直近 max_commits 件までに限定（古いファイルは情報なしになる場合あり）。
+    """
+    try:
+        proc = subprocess.run(
+            ["git", "-C", root, "log", "-n", str(max_commits),
+             "--name-only", "--date=relative",
+             "--pretty=format:\x01%H\x02%ad\x02%an\x02%s\x03"],
+            capture_output=True, text=True, timeout=8, check=True,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError,
+            subprocess.TimeoutExpired, OSError):
+        return {}
+
+    file_map = {}
+    current = None
+    for raw in proc.stdout.split("\n"):
+        line = raw.strip("\r")
+        if line.startswith("\x01"):
+            body = line[1:]
+            if body.endswith("\x03"):
+                body = body[:-1]
+            parts = body.split("\x02", 3)
+            current = ({"hash": parts[0][:7], "date": parts[1],
+                        "author": parts[2], "subject": parts[3]}
+                       if len(parts) == 4 else None)
+        elif line.strip() and current is not None:
+            fp = line.strip().replace("\\", "/")
+            if fp not in file_map:
+                file_map[fp] = current
+    return file_map
+
+def fmt_git(g):
+    if not g: return None
+    subj = g["subject"].strip()
+    if len(subj) > 30:
+        subj = subj[:30] + "…"
+    return f'"{subj}" ({g["date"]})'
+
+
+# --- TODO/FIXME抽出（-K / --todo） -----------------------------
+_TODO_RE = re.compile(r'\b(TODO|FIXME|HACK|XXX)\b[:\s]?(.*)', re.IGNORECASE)
+
+def scan_todos(path, limit_bytes=2_000_000):
+    if _is_probably_binary(path):
+        return []
+    try:
+        with open(path, "rb") as f:
+            data = f.read(limit_bytes)
+    except OSError:
+        return []
+    if b"\x00" in data[:8192]:
+        return []
+    text = data.decode("utf-8", errors="ignore")
+    results = []
+    for i, line in enumerate(text.split("\n"), 1):
+        m = _TODO_RE.search(line)
+        if m:
+            snippet = line.strip()
+            if len(snippet) > 80:
+                snippet = snippet[:80] + "…"
+            results.append((i, m.group(1).upper(), snippet))
+    return results
+
+
+# --- テスト欠落検知（-V / --missing-tests） ---------------------
+_SOURCE_EXTS_FOR_TESTS = {".py", ".js", ".jsx", ".ts", ".tsx", ".go"}
+
+def _is_test_file(name):
+    lower = name.lower()
+    stem, ext = os.path.splitext(lower)
+    if stem.startswith("test_") or stem.endswith("_test"):
+        return True
+    if stem.endswith(".test") or stem.endswith(".spec"):
+        return True
+    return False
+
+
+# --- import/依存グラフ解析（-M / --imports） ---------------------
+# Pythonは標準ライブラリの ast モジュールで正確に解析。
+# JS/TS/Go/Rustは正規表現ベースの抽出＋相対パス解決（best-effort）。
+# 外部パッケージ（react, lodash, requests 等）はプロジェクト内ファイルに
+# 解決できないため "external" 扱いとし、依存グラフには含めない。
+
+def extract_imports_py(path):
+    """ASTでPythonのimport文を正確に抽出する。
+    戻り値: [(module_str, level, [imported_names])]  level>0 は相対import。
+    """
+    try:
+        with open(path, encoding="utf-8", errors="ignore") as f:
+            source = f.read()
+        tree = ast.parse(source, filename=path)
+    except (OSError, SyntaxError, ValueError, RecursionError):
+        return []
+    out = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                out.append((alias.name, 0, None))
+        elif isinstance(node, ast.ImportFrom):
+            out.append((node.module or "", node.level, [a.name for a in node.names]))
+    return out
+
+_JS_IMPORT_PATTERNS = [
+    re.compile(r'''import\s+(?:[\w*\s{},]+\s+from\s+)?['"]([^'"]+)['"]'''),
+    re.compile(r'''export\s+(?:[\w*\s{},]+\s+from\s+)?['"]([^'"]+)['"]'''),
+    re.compile(r'''require\(\s*['"]([^'"]+)['"]\s*\)'''),
+    re.compile(r'''import\(\s*['"]([^'"]+)['"]\s*\)'''),  # 動的import()
+]
+
+def extract_imports_js(path):
+    try:
+        with open(path, encoding="utf-8", errors="ignore") as f:
+            text = f.read()
+    except OSError:
+        return []
+    found = []
+    for pat in _JS_IMPORT_PATTERNS:
+        found.extend(pat.findall(text))
+    return found
+
+_GO_IMPORT_BLOCK_RE = re.compile(r'import\s*\(([^)]*)\)', re.DOTALL)
+_GO_IMPORT_LINE_RE  = re.compile(r'import\s+"([^"]+)"')
+_GO_IMPORT_ITEM_RE  = re.compile(r'"([^"]+)"')
+
+def extract_imports_go(path):
+    try:
+        with open(path, encoding="utf-8", errors="ignore") as f:
+            text = f.read()
+    except OSError:
+        return []
+    found = []
+    block = _GO_IMPORT_BLOCK_RE.search(text)
+    if block:
+        found.extend(_GO_IMPORT_ITEM_RE.findall(block.group(1)))
+    found.extend(_GO_IMPORT_LINE_RE.findall(text))
+    return found
+
+_RS_USE_RE = re.compile(r'^\s*(?:pub\s+)?use\s+([\w:]+)', re.MULTILINE)
+_RS_MOD_RE = re.compile(r'^\s*(?:pub\s+)?mod\s+(\w+)\s*;', re.MULTILINE)
+
+def extract_imports_rs(path):
+    """戻り値: (use文のパスリスト, mod宣言のモジュール名リスト)"""
+    try:
+        with open(path, encoding="utf-8", errors="ignore") as f:
+            text = f.read()
+    except OSError:
+        return [], []
+    return _RS_USE_RE.findall(text), _RS_MOD_RE.findall(text)
+
+
+def _py_module_key(relpath):
+    """'pkg/sub/mod.py' -> 'pkg.sub.mod'、'pkg/sub/__init__.py' -> 'pkg.sub'"""
+    parts = relpath.replace("\\", "/").split("/")
+    if parts[-1] == "__init__.py":
+        parts = parts[:-1]
+    elif parts[-1].endswith(".py"):
+        parts[-1] = parts[-1][:-3]
+    return ".".join(parts)
+
+def _resolve_relative_path(base_dir, target, project_files):
+    """JS/TS の相対import（'./foo'、'../bar'）をプロジェクト内ファイルに解決する。"""
+    candidate = os.path.normpath(os.path.join(base_dir, target)).replace("\\", "/")
+    for suffix in ("", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+                   "/index.js", "/index.ts", "/index.jsx", "/index.tsx"):
+        cand = candidate + suffix
+        if cand in project_files:
+            return cand
+    return None
+
+def _resolve_rust_crate_path(use_path, project_files):
+    """'crate::foo::bar::Baz' をプロジェクト内ファイルに解決する（src/foo/bar.rs 等）。
+    self:: / super:: および外部crateは簡易実装のため非対応（external扱い）。
+    """
+    if not use_path.startswith("crate::"):
+        return None
+    body = use_path.split("::", 1)[1]
+    segments = [s for s in body.split("::") if s and s not in ("self", "*")]
+    for cut in (len(segments), len(segments) - 1):
+        if cut <= 0: continue
+        path_part = "/".join(segments[:cut])
+        for cand in (f"src/{path_part}.rs", f"src/{path_part}/mod.rs"):
+            if cand in project_files:
+                return cand
+    return None
+
+
+# --- エントリーポイント検出（-N / --entry） ----------------------
+_ENTRY_NAMES_LOWER = {
+    "main.py", "__main__.py", "app.py", "server.py", "manage.py", "wsgi.py", "asgi.py",
+    "index.js", "index.ts", "index.mjs", "index.cjs",
+    "main.js", "main.ts", "server.js", "server.ts", "app.js", "app.ts",
+    "main.go", "main.rs",
+    "makefile", "dockerfile", "docker-compose.yml", "docker-compose.yaml",
+}
+
+
+def build_project_index(root, cfg):
+    """テスト欠落検知・エントリーポイント検出・import依存グラフのため、
+    プロジェクト全体を一度だけスキャンする。
+    .gitignore は -G 指定時のみ尊重する。-G なしで巨大な node_modules 等があると遅くなる場合がある。
+    戻り値: (untested_relpaths, entry_relpaths, imports_map, imported_by_map, external_map)
+    """
+    all_names = set()
+    all_relpaths = set()
+    source_files = []
+    entry_set = set()
+    py_module_map = {}
+    go_module_name = [None]  # nonlocalの代わりにリストで包む
+
+    def walk(path, active_pats):
+        pats = _extend_pats(active_pats, path, cfg) if cfg.use_gitignore else active_pats
+        try:
+            entries = list(os.scandir(path))
+        except OSError:
+            return
+        entries = [e for e in entries if cfg.show_all or not e.name.startswith(".")]
+        if pats:
+            entries = [e for e in entries
+                       if not is_ignored(e.name, os.path.relpath(e.path, root),
+                                         e.is_dir(follow_symlinks=False), pats)]
+        for e in entries:
+            if e.is_dir(follow_symlinks=False):
+                walk(e.path, pats)
+                continue
+            relpath = os.path.relpath(e.path, root).replace("\\", "/")
+            stem, ext = os.path.splitext(e.name)
+            all_names.add(e.name.lower())
+            all_relpaths.add(relpath)
+            if ext.lower() in _SOURCE_EXTS_FOR_TESTS and not _is_test_file(e.name):
+                source_files.append((relpath, stem, ext.lower()))
+            if e.name.lower() in _ENTRY_NAMES_LOWER:
+                entry_set.add(relpath)
+            if ext.lower() == ".py":
+                py_module_map[_py_module_key(relpath)] = relpath
+            if e.name == "go.mod":
+                try:
+                    with open(e.path, encoding="utf-8", errors="ignore") as f:
+                        for line in f:
+                            line = line.strip()
+                            if line.startswith("module "):
+                                go_module_name[0] = line.split(None, 1)[1].strip()
+                                break
+                except OSError:
+                    pass
+            if e.name == "package.json":
+                try:
+                    with open(e.path, encoding="utf-8") as f:
+                        pkg = json.load(f)
+                    base_dir = os.path.dirname(relpath)
+                    main_field = pkg.get("main")
+                    if isinstance(main_field, str):
+                        entry_set.add(os.path.normpath(
+                            os.path.join(base_dir, main_field)).replace("\\", "/"))
+                    bin_field = pkg.get("bin")
+                    if isinstance(bin_field, str):
+                        entry_set.add(os.path.normpath(
+                            os.path.join(base_dir, bin_field)).replace("\\", "/"))
+                    elif isinstance(bin_field, dict):
+                        for v in bin_field.values():
+                            if isinstance(v, str):
+                                entry_set.add(os.path.normpath(
+                                    os.path.join(base_dir, v)).replace("\\", "/"))
+                except (OSError, json.JSONDecodeError, AttributeError, ValueError):
+                    pass
+
+    walk(root, [])
+
+    untested = set()
+    for relpath, stem, ext in source_files:
+        candidates = {f"test_{stem}{ext}", f"{stem}_test{ext}",
+                      f"{stem}.test{ext}", f"{stem}.spec{ext}"}
+        if not (candidates & all_names):
+            untested.add(relpath)
+
+    imports_map, imported_by_acc, external_map = {}, {}, {}
+    if cfg.show_imports:
+        for relpath in sorted(all_relpaths):
+            ext = os.path.splitext(relpath)[1].lower()
+            full_path = os.path.join(root, relpath)
+            base_dir = os.path.dirname(relpath)
+            local_targets, external_raw = set(), []
+
+            if ext == ".py":
+                for mod, level, names in extract_imports_py(full_path):
+                    if level and level > 0:
+                        pkg_parts = base_dir.split("/") if base_dir else []
+                        up = level - 1
+                        pkg_parts = pkg_parts[:-up] if (up and up <= len(pkg_parts)) else \
+                                    (pkg_parts if not up else [])
+                        target_key = ".".join(pkg_parts + ([mod] if mod else []))
+                        resolved = None
+                        # 'from .pkg import sub' は sub がサブモジュールの可能性があるため、
+                        # まず names を「パッケージ内のサブモジュール」として解決を試みる
+                        # （例: from . import app_helpers → app_helpers.py）
+                        if names:
+                            for nm in names:
+                                cand_key = f"{target_key}.{nm}" if target_key else nm
+                                resolved = py_module_map.get(cand_key)
+                                if resolved: break
+                        # 解決できなければ、import先自体がモジュールである通常パターンにフォールバック
+                        # （例: from .utils import helper_function → utils.py）
+                        if not resolved:
+                            resolved = py_module_map.get(target_key)
+                        if resolved and resolved != relpath:
+                            local_targets.add(resolved)
+                        else:
+                            external_raw.append("." * level + (mod or ""))
+                    else:
+                        resolved = py_module_map.get(mod)
+                        if resolved and resolved != relpath:
+                            local_targets.add(resolved)
+                        else:
+                            external_raw.append(mod)
+
+            elif ext in (".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"):
+                for spec in extract_imports_js(full_path):
+                    if spec.startswith(".") or spec.startswith("/"):
+                        resolved = _resolve_relative_path(base_dir, spec, all_relpaths)
+                        if resolved and resolved != relpath:
+                            local_targets.add(resolved)
+                        else:
+                            external_raw.append(spec)
+                    else:
+                        external_raw.append(spec)
+
+            elif ext == ".go":
+                mod_name = go_module_name[0]
+                for spec in extract_imports_go(full_path):
+                    if mod_name and spec.startswith(mod_name):
+                        sub = spec[len(mod_name):].lstrip("/")
+                        candidates = [r for r in all_relpaths if r.endswith(".go") and
+                                     (r.startswith(sub + "/") or os.path.dirname(r) == sub)]
+                        if candidates:
+                            for cand in candidates:
+                                if cand != relpath:
+                                    local_targets.add(cand)
+                        else:
+                            external_raw.append(spec)
+                    else:
+                        external_raw.append(spec)
+
+            elif ext == ".rs":
+                uses, mods = extract_imports_rs(full_path)
+                for m in mods:
+                    for cand in (f"{base_dir}/{m}.rs" if base_dir else f"{m}.rs",
+                                f"{base_dir}/{m}/mod.rs" if base_dir else f"{m}/mod.rs"):
+                        if cand in all_relpaths:
+                            local_targets.add(cand)
+                for u in uses:
+                    resolved = _resolve_rust_crate_path(u, all_relpaths)
+                    if resolved and resolved != relpath:
+                        local_targets.add(resolved)
+                    else:
+                        external_raw.append(u)
+
+            if local_targets:
+                imports_map[relpath] = sorted(local_targets)
+                for t in local_targets:
+                    imported_by_acc.setdefault(t, set()).add(relpath)
+            if external_raw:
+                # 重複除去しつつ最大10件まで
+                seen = []
+                for x in external_raw:
+                    if x and x not in seen:
+                        seen.append(x)
+                external_map[relpath] = seen[:10]
+
+    imported_by_map = {k: sorted(v) for k, v in imported_by_acc.items()}
+    return untested, entry_set, imports_map, imported_by_map, external_map
+
+
+# --- シンボルアウトライン（-O / --outline） ----------------------
+# 正規表現ベースの簡易抽出。AST解析ではないため、デコレータが複雑な場合や
+# 複数行にまたがる関数シグネチャ等は取得漏れすることがある（best-effort）。
+_JS_TS_PATTERNS = [
+    (re.compile(r'^\s*(?:export\s+)?(?:default\s+)?class\s+(\w+)'), "class"),
+    (re.compile(r'^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s+(\w+)\s*\('), "func"),
+    (re.compile(r'^\s*export\s+(?:default\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\('), "func"),
+    (re.compile(r'^\s*(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(.*\)\s*=>'), "func"),
+]
+_OUTLINE_PATTERNS = {
+    ".py": [
+        (re.compile(r'^(\s*)class\s+(\w+)'), "class"),
+        (re.compile(r'^(\s*)(?:async\s+)?def\s+(\w+)\s*\('), "def"),
+    ],
+    ".go": [
+        (re.compile(r'^func\s+(?:\([^)]*\)\s+)?(\w+)\s*\('), "func"),
+        (re.compile(r'^type\s+(\w+)\s+struct'), "struct"),
+        (re.compile(r'^type\s+(\w+)\s+interface'), "interface"),
+    ],
+    ".rs": [
+        (re.compile(r'^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+(\w+)'), "fn"),
+        (re.compile(r'^\s*(?:pub(?:\([^)]*\))?\s+)?struct\s+(\w+)'), "struct"),
+        (re.compile(r'^\s*(?:pub(?:\([^)]*\))?\s+)?enum\s+(\w+)'), "enum"),
+        (re.compile(r'^\s*(?:pub(?:\([^)]*\))?\s+)?trait\s+(\w+)'), "trait"),
+    ],
+}
+for _e in (".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"):
+    _OUTLINE_PATTERNS[_e] = _JS_TS_PATTERNS
+
+def extract_outline(path, ext, limit_lines=4000):
+    """対応言語（Python/JS/TS/Go/Rust）の関数・クラス名を正規表現で簡易抽出する。
+    対応外の拡張子は None を返す（「対応していない」ことを明示するため空リストとは区別）。
+    """
+    patterns = _OUTLINE_PATTERNS.get(ext)
+    if not patterns:
+        return None
+    try:
+        with open(path, encoding="utf-8", errors="ignore") as f:
+            lines = []
+            for i, line in enumerate(f):
+                if i >= limit_lines:
+                    break
+                lines.append(line)
+    except OSError:
+        return []
+    out = []
+    for line in lines:
+        for pat, kind in patterns:
+            m = pat.match(line)
+            if m:
+                out.append((kind, m.group(m.lastindex)))
+                break
+    return out
+
+def fmt_outline(outline, limit=5):
+    if not outline:
+        return None
+    items = [f"{kind} {name}" for kind, name in outline]
+    shown = items[:limit]
+    s = ", ".join(shown)
+    if len(items) > limit:
+        s += f", +{len(items)-limit}"
+    return s
+
+
+def _file_extras(entry, relpath, cfg):
+    """有効になっているAI解析フラグに応じて、ファイル単位の追加情報を計算する。"""
+    extras = {}
+    ext = os.path.splitext(entry.name)[1].lower()
+
+    if cfg.show_tokens:
+        if _is_probably_binary(entry.name):
+            extras["tokens"] = None
+        else:
+            try: sz = entry.stat(follow_symlinks=True).st_size
+            except OSError: sz = None
+            extras["tokens"] = estimate_tokens(entry.path, actual_size=sz)
+
+    if cfg.show_git:
+        extras["git"] = cfg.git_map.get(relpath)
+
+    if cfg.show_todo:
+        extras["todos"] = scan_todos(entry.path)
+
+    if cfg.show_entry:
+        extras["is_entry"] = relpath in cfg.entry_set
+
+    if cfg.show_tests:
+        extras["no_test"] = relpath in cfg.untested_set
+
+    if cfg.show_outline:
+        extras["outline"] = extract_outline(entry.path, ext)
+
+    if cfg.show_imports:
+        extras["imports"] = cfg.imports_map.get(relpath, [])
+        extras["imported_by"] = cfg.imported_by_map.get(relpath, [])
+        extras["external_imports"] = cfg.external_map.get(relpath, [])
+
+    return extras
+
+
+# ════════════════════════════════════════════════════════════
+
+
 # ─── 設定クラス ───────────────────────────────────────────────
 class Cfg:
     def __init__(self, args, root):
@@ -275,6 +804,25 @@ class Cfg:
         self.reverse       = args.reverse
         self.files_first   = args.filesfirst
 
+        # AI/エージェント向け解析フラグ
+        self.show_tokens   = args.tokens       # -T
+        self.show_git      = args.git          # -H
+        self.show_todo     = args.todo         # -K
+        self.show_tests    = args.tests        # -V
+        self.show_entry    = args.entry        # -N
+        self.show_outline  = args.outline      # -O
+        self.show_imports  = args.imports      # -M
+        self.has_extras    = any([self.show_tokens, self.show_git, self.show_todo,
+                                   self.show_tests, self.show_entry, self.show_outline,
+                                   self.show_imports])
+        # main() 側で必要に応じて埋める
+        self.git_map        = {}
+        self.untested_set   = set()
+        self.entry_set      = set()
+        self.imports_map    = {}
+        self.imported_by_map = {}
+        self.external_map   = {}
+
 
 # ─── 共通フィルタリング ───────────────────────────────────────
 def _filter(path, cfg, active_pats):
@@ -298,7 +846,6 @@ def _filter(path, cfg, active_pats):
                     and e.is_dir(follow_symlinks=True)]
         dirs = dirs + sym_dirs
 
-    # -d (dirs only): ファイルを非表示
     if cfg.dirs_only:
         files = []
     else:
@@ -336,7 +883,7 @@ def _has_content(path, depth, cfg, active_pats):
     if cfg.max_depth is not None and depth >= cfg.max_depth: return False
     pats = _extend_pats(active_pats, path, cfg)
     dirs, files = _filter(path, cfg, pats)
-    if dirs is None: return False  # アクセス拒否は空とみなす
+    if dirs is None: return False
     if files: return True
     for d in dirs:
         if _has_content(d.path, depth + 1, cfg, pats): return True
@@ -345,7 +892,6 @@ def _has_content(path, depth, cfg, active_pats):
 
 # ─── ソートヘルパー ───────────────────────────────────────────
 def _sort_entries(dirs, files, cfg):
-    """設定に基づいてdirs/filesをソートする（-t/-c/-S/-r対応）。"""
     def emtime(e):
         try: return e.stat(follow_symlinks=True).st_mtime
         except OSError: return 0
@@ -357,16 +903,16 @@ def _sort_entries(dirs, files, cfg):
         except OSError: return 0
 
     rev = cfg.reverse
-    if cfg.sort_mtime:          # -t: 更新日時順（新しい順）
+    if cfg.sort_mtime:
         dirs.sort(key=emtime,  reverse=not rev)
         files.sort(key=emtime, reverse=not rev)
-    elif cfg.sort_ctime:         # -c: ctime順（新しい順）
+    elif cfg.sort_ctime:
         dirs.sort(key=ectime,  reverse=not rev)
         files.sort(key=ectime, reverse=not rev)
-    elif cfg.by_size:            # -S: サイズ順（大きい順）
+    elif cfg.by_size:
         dirs.sort(key=lambda e: dir_size(e.path)[0], reverse=not rev)
         files.sort(key=esz, reverse=not rev)
-    else:                        # デフォルト: アルファベット順
+    else:
         dirs.sort(key=lambda e: e.name.casefold(), reverse=rev)
         files.sort(key=lambda e: e.name.casefold(), reverse=rev)
 
@@ -389,7 +935,7 @@ def render(path, prefix, depth, cfg, stats, active_pats, _seen=None):
 
     cur_pats = _extend_pats(active_pats, path, cfg)
     dirs, files = _filter(path, cfg, cur_pats)
-    if dirs is None:  # アクセス拒否
+    if dirs is None:
         print(f"{prefix}{LAST}{c('[アクセス拒否]', BOLD, RED)}")
         return
 
@@ -450,21 +996,62 @@ def render(path, prefix, depth, cfg, stats, active_pats, _seen=None):
             stats["extensions"][ext or "(no ext)"] = \
                 stats["extensions"].get(ext or "(no ext)", 0) + 1
 
+            rel = os.path.relpath(entry.path, cfg.root).replace("\\", "/")
+            extras = _file_extras(entry, rel, cfg) if cfg.has_extras else {}
+
+            entry_mark = ""
+            if extras.get("is_entry"):
+                entry_mark = "🎯 " if cfg.show_emoji else "* "
+                stats["entries"] += 1
+
             emoji = (get_emoji(entry.name) + " ") if cfg.show_emoji else ""
-            parts = [fmt_size(sz)]   # ファイルサイズは stat() で正確に取れるので + なし
+            parts = [fmt_size(sz)]
             if cfg.show_date:
                 mt = emtime(entry)
                 if mt: parts.append(fmt_date(mt))
+
+            if cfg.show_tokens and extras.get("tokens") is not None:
+                parts.append(fmt_tokens(extras["tokens"]))
+                stats["tokens"] += extras["tokens"]
+
+            if cfg.show_git and extras.get("git"):
+                parts.append(fmt_git(extras["git"]))
+
+            if cfg.show_todo and extras.get("todos"):
+                n_todo = len(extras["todos"])
+                parts.append(f"TODO×{n_todo}")
+                stats["todo_total"] += n_todo
+                for item in extras["todos"][:3]:
+                    if len(stats["todo_samples"]) < 20:
+                        stats["todo_samples"].append((rel, *item))
+
+            if cfg.show_tests and extras.get("no_test"):
+                parts.append("テスト無し")
+                stats["no_test"] += 1
+
+            if cfg.show_outline and extras.get("outline"):
+                ostr = fmt_outline(extras["outline"])
+                if ostr: parts.append(ostr)
+
+            if cfg.show_imports:
+                imp_n  = len(extras.get("imports") or [])
+                used_n = len(extras.get("imported_by") or [])
+                if imp_n:  parts.append(f"imports×{imp_n}")
+                if used_n: parts.append(f"used-by×{used_n}")
+
             bar = (" " + fmt_bar(sz, cur_dir_size)) if cfg.show_bar and cur_dir_size else ""
 
-            name = c(f"{emoji}{display}{sym_target}",
+            name = c(f"{entry_mark}{display}{sym_target}",
                      MAGENTA if entry.is_symlink() else GREEN)
             meta = c(f"({', '.join(parts)}){bar}", DIM)
             print(f"{prefix}{branch}{perm_prefix}{name} {meta}")
 
 
 # ─── JSON出力 ─────────────────────────────────────────────────
-def build_json_tree(path, depth, cfg, active_pats):
+def build_json_tree(path, depth, cfg, active_pats, stats=None):
+    if stats is None:
+        stats = {"tokens": 0, "todo_total": 0, "todo_samples": [], "no_test": 0, "entries": 0}
+
     cur_pats = _extend_pats(active_pats, path, cfg)
     dirs, files = _filter(path, cfg, cur_pats)
     denied = dirs is None
@@ -483,15 +1070,47 @@ def build_json_tree(path, depth, cfg, active_pats):
         combined = (files + dirs) if cfg.files_first else (dirs + files)
         for entry in combined:
             if entry.is_dir(follow_symlinks=False):
-                children.append(build_json_tree(entry.path, depth + 1, cfg, cur_pats))
+                children.append(build_json_tree(entry.path, depth + 1, cfg, cur_pats, stats))
             else:
                 f_sz = esz(entry)
-                children.append({
+                rel = os.path.relpath(entry.path, cfg.root).replace("\\", "/")
+                extras = _file_extras(entry, rel, cfg) if cfg.has_extras else {}
+
+                file_obj = {
                     "name": entry.name, "type": "file",
                     "size": f_sz, "size_human": fmt_size(f_sz),
                     "ext": os.path.splitext(entry.name)[1].lower(),
-                    "path": os.path.relpath(entry.path, cfg.root),
-                })
+                    "path": rel,
+                }
+                if cfg.show_tokens:
+                    file_obj["tokens"] = extras.get("tokens")
+                    if extras.get("tokens") is not None:
+                        stats["tokens"] += extras["tokens"]
+                if cfg.show_git:
+                    file_obj["git"] = extras.get("git")
+                if cfg.show_todo:
+                    todos = extras.get("todos") or []
+                    file_obj["todos"] = [{"line": ln, "kind": k, "text": s} for ln, k, s in todos]
+                    stats["todo_total"] += len(todos)
+                    for item in todos[:3]:
+                        if len(stats["todo_samples"]) < 20:
+                            stats["todo_samples"].append((rel, *item))
+                if cfg.show_tests:
+                    file_obj["has_test"] = not extras.get("no_test", False)
+                    if extras.get("no_test"): stats["no_test"] += 1
+                if cfg.show_entry:
+                    file_obj["is_entry"] = bool(extras.get("is_entry"))
+                    if extras.get("is_entry"): stats["entries"] += 1
+                if cfg.show_outline:
+                    outline = extras.get("outline")
+                    file_obj["outline"] = ([{"kind": k, "name": n} for k, n in outline]
+                                           if outline else outline)  # None=対応外言語
+                if cfg.show_imports:
+                    file_obj["imports"] = extras.get("imports") or []
+                    file_obj["imported_by"] = extras.get("imported_by") or []
+                    file_obj["external_imports"] = extras.get("external_imports") or []
+
+                children.append(file_obj)
 
     name = os.path.basename(path) or path
     return {
@@ -537,10 +1156,21 @@ def generate_html(root_path, cfg, active_pats):
                 if entry.is_symlink():
                     try: sym = f' → {os.readlink(entry.path)}'
                     except OSError: sym = ' →'
+
+                rel = os.path.relpath(entry.path, cfg.root).replace("\\", "/")
+                extras = _file_extras(entry, rel, cfg) if cfg.has_extras else {}
+                badges = ""
+                if extras.get("is_entry"):
+                    badges += '<span class="badge entry">entry</span>'
+                if extras.get("no_test"):
+                    badges += '<span class="badge notest">no test</span>'
+                if extras.get("todos"):
+                    badges += f'<span class="badge todo">TODO×{len(extras["todos"])}</span>'
+
                 ch += (f'<div class="item file">'
                        f'<span class="emoji">{get_emoji(entry.name)}</span>'
                        f'<span class="fname"> {entry.name}{sym}</span>'
-                       f'<span class="sz"> {fmt_size(f_sz)}</span></div>\n')
+                       f'<span class="sz"> {fmt_size(f_sz)}</span>{badges}</div>\n')
 
         nd, nf = len(dirs), len(files)
         opened = " open" if depth == 0 else ""
@@ -573,6 +1203,11 @@ summary:hover{{background:rgba(255,255,255,.06)}}
 .item:hover{{background:rgba(255,255,255,.05);border-radius:4px}}
 .fname{{color:#a6e3a1}}.sz{{color:#585b70;font-size:12px}}
 .emoji{{width:1.6em;display:inline-block}}.hidden{{display:none!important}}
+.badge{{display:inline-block;margin-left:6px;padding:0 6px;border-radius:8px;
+        font-size:10px;vertical-align:middle}}
+.badge.entry{{background:#89b4fa;color:#1e1e2e}}
+.badge.notest{{background:#f9e2af;color:#1e1e2e}}
+.badge.todo{{background:#f38ba8;color:#1e1e2e}}
 </style></head><body>
 <h1>🌳 dirlens — {root_name}</h1>
 <input id="q" type="text" placeholder="ファイル名で検索…" oninput="search(this.value)">
@@ -580,18 +1215,13 @@ summary:hover{{background:rgba(255,255,255,.06)}}
 <script>
 function search(q){{
   q=q.toLowerCase().trim();
-  // まず全要素を表示に戻す
   document.querySelectorAll('.hidden').forEach(el=>el.classList.remove('hidden'));
   if(!q) return;
-  // 全ディレクトリを展開
   document.querySelectorAll('details').forEach(d=>d.open=true);
-  // マッチしないファイルを非表示
   document.querySelectorAll('.file').forEach(el=>{{
     const n=el.querySelector('.fname')?.textContent.toLowerCase()||'';
     if(!n.includes(q)) el.classList.add('hidden');
   }});
-  // visible なファイルを1つも持たないディレクトリを非表示
-  // （空ディレクトリ・検索に引っかからないディレクトリ両方を処理）
   document.querySelectorAll('#tree details').forEach(detail=>{{
     const hasVisible=[...detail.querySelectorAll('.file')]
       .some(f=>!f.classList.contains('hidden'));
@@ -612,15 +1242,18 @@ def main():
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=(
             "使用例:\n"
-            "  dirlens --ai            AIチャット貼り付け用（推奨）\n"
-            "  dirlens -d              ディレクトリのみ表示（tree -d 互換）\n"
-            "  dirlens -L 2            深さ 2 まで表示（tree -L 互換）\n"
-            "  dirlens -t              更新日時順にソート（tree -t 互換）\n"
-            "  dirlens -G --prune      gitignore除外 + 空枝を剪定\n"
-            "  dirlens -p -u -g        パーミッション・ユーザー・グループ表示\n"
-            "  dirlens -e py           .pyのみ表示（旧 -t）\n"
-            "  dirlens -S              サイズ順ソート（旧 -s）\n"
-            "  dirlens -C              クリップボードにコピー（旧 -c）\n"
+            "  dirlens --ai             AIチャット貼り付け用（人間がコピペする想定）\n"
+            "  dirlens --agent          エージェント向け解析（クリップボードは使わない）\n"
+            "  dirlens -d               ディレクトリのみ表示（tree -d 互換）\n"
+            "  dirlens -L 2             深さ 2 まで表示（tree -L 互換）\n"
+            "  dirlens -G --prune       gitignore除外 + 空枝を剪定\n"
+            "  dirlens -T               ファイルごとの推定トークン数を表示\n"
+            "  dirlens -H               最終コミット情報を表示（要git）\n"
+            "  dirlens -K               TODO/FIXME/HACKを抽出\n"
+            "  dirlens -V               テストが無いソースファイルを表示\n"
+            "  dirlens -N               エントリーポイントらしきファイルをマーク\n"
+            "  dirlens -O               関数・クラスの簡易アウトラインを表示\n"
+            "  dirlens -M               ローカルなimport/依存関係を解析\n"
             "  dirlens --no-color > dirlens.txt   ファイルに書き出す"
         ),
     )
@@ -667,6 +1300,23 @@ def main():
     ap.add_argument("-I", dest="exclude_tree", metavar="PATTERN", action="append",
                     help="除外パターン（tree -I 互換）")
 
+    # ── AI/エージェント向け解析フラグ ─────────────────────────
+    ap.add_argument("-T", "--tokens",    action="store_true",
+                    help="ファイルごとの推定トークン数を表示（概算）")
+    ap.add_argument("-H", "--git",       action="store_true",
+                    help="最終コミット情報を表示（要git、直近2000コミットまで走査）")
+    ap.add_argument("-K", "--todo",      action="store_true",
+                    help="TODO/FIXME/HACK/XXXコメントを抽出")
+    ap.add_argument("-V", "--missing-tests", action="store_true", dest="tests",
+                    help="対応するテストファイルが見つからないソースファイルを表示")
+    ap.add_argument("-N", "--entry",     action="store_true",
+                    help="エントリーポイントらしきファイルを検出してマーク")
+    ap.add_argument("-O", "--outline",   action="store_true",
+                    help="関数・クラスの簡易アウトラインを表示（正規表現ベース・対応言語限定）")
+    ap.add_argument("-M", "--imports",   action="store_true",
+                    help="ローカルなimport/依存関係を解析して表示（Python/JS/TS/Go/Rust対応、"
+                         "正確さは言語による。外部パッケージは対象外）")
+
     # ── dirlens独自オプション ─────────────────────────────────
     ap.add_argument("path",              nargs="?", default=".")
     ap.add_argument("--depth",           type=int,  metavar="N",
@@ -685,7 +1335,9 @@ def main():
     ap.add_argument("--prune",           action="store_true")
     ap.add_argument("--filesfirst",      action="store_true")
     ap.add_argument("--ai",              action="store_true",
-                    help="-G --date -m -C のショートカット")
+                    help="-G --date -m -C のショートカット（人間がAIチャットに貼り付ける用）")
+    ap.add_argument("--agent",           action="store_true",
+                    help="-G -T -H -K -V -N -O のショートカット（エージェント向け解析、クリップボードは使わない）")
     args = ap.parse_args()
 
     # ── エイリアスのマージ ────────────────────────────────────
@@ -696,13 +1348,25 @@ def main():
     if args.no_color_tree:          args.no_color = True
     if args.json_tree:              args.json     = True
 
-    # --ai: -G --date -m -C のショートカット
+    # --ai: 人間がAIチャットに貼り付けるためのショートカット（クリップボードを使う）
     if args.ai:
         args.gitignore = True
         args.date      = True
         args.markdown  = True
         args.copy      = True
 
+    # --agent: エージェントが自律実行しても安全なショートカット（クリップボードは使わない）
+    if args.agent:
+        args.gitignore = True
+        args.date      = True
+        args.tokens    = True
+        args.git       = True
+        args.todo      = True
+        args.tests     = True
+        args.entry     = True
+        args.outline   = True
+        args.imports   = True
+
     if args.no_color or args.markdown or args.json:
         USE_COLOR = False
 
@@ -714,12 +1378,33 @@ def main():
 
     cfg = Cfg(args, str(target))
     active_pats = load_gitignore(str(target)) if args.gitignore else []
+
+    if cfg.show_tests or cfg.show_entry or cfg.show_imports:
+        (cfg.untested_set, cfg.entry_set,
+         cfg.imports_map, cfg.imported_by_map, cfg.external_map) = build_project_index(str(target), cfg)
+    if cfg.show_git:
+        cfg.git_map = load_git_log(str(target))
+
     _prefetch_sizes(str(target))
 
     # ── JSON ─────────────────────────────────────────────────
     if args.json:
-        print(json.dumps(build_json_tree(str(target), 0, cfg, active_pats),
-                         ensure_ascii=False, indent=2)); return
+        stats = {"tokens": 0, "todo_total": 0, "todo_samples": [], "no_test": 0, "entries": 0}
+        tree = build_json_tree(str(target), 0, cfg, active_pats, stats)
+        if cfg.has_extras:
+            most_depended = None
+            if cfg.show_imports and cfg.imported_by_map:
+                top = sorted(cfg.imported_by_map.items(), key=lambda kv: -len(kv[1]))[:10]
+                most_depended = [{"path": p, "used_by_count": len(v)} for p, v in top]
+            tree["project_summary"] = {
+                "estimated_tokens": stats["tokens"] if cfg.show_tokens else None,
+                "todo_count": stats["todo_total"] if cfg.show_todo else None,
+                "missing_tests_count": stats["no_test"] if cfg.show_tests else None,
+                "entry_points_count": stats["entries"] if cfg.show_entry else None,
+                "git_available": bool(cfg.git_map) if cfg.show_git else None,
+                "most_depended_on": most_depended,
+            }
+        print(json.dumps(tree, ensure_ascii=False, indent=2)); return
 
     # ── HTML ─────────────────────────────────────────────────
     if args.html:
@@ -746,7 +1431,8 @@ def main():
     print(f"{c(root_emoji + root_label + '/', BOLD, BLUE)} "
           f"{c('(' + ', '.join(root_parts) + ')', DIM)}")
 
-    stats = {"files": 0, "dirs": 0, "extensions": {}}
+    stats = {"files": 0, "dirs": 0, "extensions": {},
+             "tokens": 0, "todo_total": 0, "todo_samples": [], "no_test": 0, "entries": 0}
     render(str(target), "", 0, cfg, stats, active_pats)
 
     print()
@@ -767,6 +1453,35 @@ def main():
         exts = sorted(stats["extensions"].items(), key=lambda x: -x[1])
         print(c("  " + "  ".join(f"{e} ×{n}" for e, n in exts[:8]), DIM))
 
+    if cfg.show_tokens:
+        print(c(f"  推定トークン数: {fmt_tokens(stats['tokens'])}", DIM))
+
+    if cfg.show_todo:
+        if stats["todo_total"]:
+            print(c(f"  TODO/FIXME等: {stats['todo_total']}件", DIM))
+            for rel, ln, kind, snippet in stats["todo_samples"][:8]:
+                print(c(f"    {rel}:{ln} [{kind}] {snippet}", DIM))
+            if stats["todo_total"] > min(len(stats["todo_samples"]), 8):
+                rest = stats["todo_total"] - min(len(stats["todo_samples"]), 8)
+                print(c(f"    …他 {rest} 件", DIM))
+        else:
+            print(c("  TODO/FIXME等: 0件", DIM))
+
+    if cfg.show_tests:
+        print(c(f"  テスト未整備: {stats['no_test']} ファイル", DIM))
+
+    if cfg.show_entry:
+        print(c(f"  エントリーポイント候補: {stats['entries']} 件検出", DIM))
+
+    if cfg.show_imports and cfg.imported_by_map:
+        top = sorted(cfg.imported_by_map.items(), key=lambda kv: -len(kv[1]))[:5]
+        print(c("  依存度が高いファイル（多くのファイルから参照されている）:", DIM))
+        for relpath, importers in top:
+            print(c(f"    {relpath}  (used by {len(importers)})", DIM))
+
+    if cfg.show_git and not cfg.git_map:
+        print(c("  (gitリポジトリではないか、git未インストールのためコミット情報は取得できませんでした)", DIM))
+
     if args.markdown: print("```")
 
     if args.copy:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirlens",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Directory tree viewer with file sizes / ファイルサイズ付きディレクトリツリー表示ツール",
   "bin": {
     "dirlens": "./bin/dirlens"