dev-memory-cli 0.18.2 → 0.19.2

package/lib/dev_memory_common.py

@@ -54,7 +54,7 @@ LEGACY_V1_FILES = ("development.md", "context.md", "sources.md")
 # Bottom-up clustering of changed-file paths into a small set of "focus
 # directories". The cluster never grows larger than this many entries; a
 # higher number gives finer granularity at the cost of a longer hint list.
-FOCUS_AREA_LIMIT = 5
+FOCUS_AREA_LIMIT = 10
 
 
 def now_iso():
@@ -581,7 +581,6 @@ def template_overview(branch_name):
             ("分支", f"- {branch_name}"),
             ("当前目标", "- 待补充"),
             ("范围边界", "- 待补充"),
-            ("当前阶段", "- 待补充"),
             ("关键约束", "- 待补充"),
         ],
     )
@@ -599,12 +598,10 @@ def template_decisions(branch_name):
 
 def template_progress(branch_name):
     return render_title_doc(
-        "当前进展",
+        "自动索引",
         [
             ("分支", f"- {branch_name}"),
             ("建议优先查看的目录", "- 待刷新"),
-            ("当前进展", "- 待补充"),
-            ("下一步", "- 待补充"),
             (
                 "自动同步区",
                 "本区由 `dev-memory-cli capture sync-working-tree` / SessionStart hook 自动刷新，请不要手工编辑。\n\n"
@@ -684,11 +681,9 @@ def template_repo_log(repo_name):
 
 def template_progress_no_git(project_name):
     return render_title_doc(
-        "当前进展（no-git 模式）",
+        "自动索引（no-git 模式）",
         [
             ("项目", f"- {project_name}"),
-            ("当前进展", "- 待补充"),
-            ("下一步", "- 待补充"),
             (
                 "自动同步区",
                 "本区由 capture / context 刷新。no-git 模式下无 git facts，保持最小骨架。\n\n"
@@ -950,6 +945,8 @@ def migrate_v1_to_v2_branch(branch_dir, branch_name):
     written = []
 
     progress_sections = list(merged_buckets.get("progress", []))
+    progress_sections = [(t, b) for t, b in progress_sections
+                         if t not in ("当前进展", "下一步")]
     if auto_block is not None:
         progress_sections.append((
             "自动同步区",
@@ -959,7 +956,7 @@ def migrate_v1_to_v2_branch(branch_dir, branch_name):
     if progress_sections:
         target = branch_dir / "progress.md"
         target.write_text(
-            render_title_doc("当前进展", [header] + progress_sections),
+            render_title_doc("自动索引", [header] + progress_sections),
             encoding="utf-8",
         )
         written.append("progress.md")
@@ -1243,7 +1240,6 @@ _CLASSIFY_PATTERNS = [
     ("decision", re.compile(r"结论[:：]|决[定议][:：]|不再|改为|采用|废弃|选择.+?不选|abandoned|adopt")),
     ("risk", re.compile(r"阻塞|注意|坑|失败|风险|卡住|gotcha|caveat|warning")),
     ("glossary", re.compile(r"即[:：]|\s即\s|指的是|对应|链接|https?://|api\s*=|缩写|术语|简称|别名")),
-    ("progress", re.compile(r"当前|已完成|下一步|commit|提交|实现|进展|todo|wip")),
 ]
 
 
@@ -1337,12 +1333,38 @@ def summarize_scopes(paths):
     return [{"scope": scope, "files": count} for scope, count in sorted(counter.items())]
 
 
+_FOCUS_EXCLUDED_PREFIXES = (
+    ".claude/", ".vscode/", ".idea/", ".git/",
+    "node_modules/", "__pycache__/", ".venv/",
+)
+
+_FOCUS_EXCLUDED_ROOT_FILES = {
+    "go.mod", "go.sum", "go.work", "go.work.sum",
+    "package.json", "package-lock.json", "pnpm-lock.yaml", "bun.lockb",
+    "tsconfig.json", "tsconfig.base.json",
+    "main.go", "main.py",
+    ".gitignore", ".editorconfig", ".prettierrc",
+    "skills-lock.json", "eden.monorepo.json",
+    "Makefile", "Dockerfile",
+}
+
+
+def _should_exclude_path(path_str):
+    if any(path_str.startswith(prefix) or path_str == prefix.rstrip("/")
+           for prefix in _FOCUS_EXCLUDED_PREFIXES):
+        return True
+    if "/" not in path_str and path_str in _FOCUS_EXCLUDED_ROOT_FILES:
+        return True
+    return False
+
+
 def _initial_parent(path_str):
-    """File path → its immediate parent directory key. Files at repo root use
-    '.', everything else uses the POSIX-style parent dir string."""
+    """File path → its immediate parent directory key. Root-level files map to
+    None (skipped by callers) since individual files are not useful focus
+    directories."""
     parent = Path(path_str).parent
     if str(parent) in ("", "."):
-        return "."
+        return None
     return parent.as_posix()
 
 
@@ -1359,6 +1381,27 @@ def _rolled_up(key):
     return Path(key).parent.as_posix()
 
 
+def _dedup_parent_child(dirs):
+    """Remove wider parents when a more specific child exists."""
+    result = []
+    for d in dirs:
+        if any(other != d and other.startswith(d + "/") for other in dirs):
+            continue
+        result.append(d)
+    return result
+
+
+def _drop_low_weight(ranked):
+    """Drop weight-1 entries when higher-weight entries exist, since a single
+    file change doesn't carry meaningful focus signal."""
+    if not ranked:
+        return ranked
+    max_weight = ranked[0][1]
+    if max_weight < 3:
+        return ranked
+    return [(k, w) for k, w in ranked if w >= 2]
+
+
 def summarize_focus_areas(paths, limit=None):
     """Cluster changed-file paths into ≤ `limit` focus directories.
 
@@ -1368,12 +1411,19 @@ def summarize_focus_areas(paths, limit=None):
     count (the "dominant cluster" — most files concentrated under a single
     deeper subtree), and merge only those originals into it. Buckets that
     were already at depth 1 or '.' are left untouched, so isolated shallow
-    directories survive. Tie-break: deeper rolled-up key wins, then
-    lexicographic.
+    directories and root-level files survive. Tie-break: deeper rolled-up key
+    wins, then lexicographic.
     """
     if limit is None:
         limit = FOCUS_AREA_LIMIT
-    buckets = Counter(_initial_parent(p) for p in paths)
+    filtered = [p for p in paths if not _should_exclude_path(p)]
+    buckets = Counter()
+    for p in filtered:
+        key = _initial_parent(p)
+        if key is not None:
+            buckets[key] += 1
+    if not buckets:
+        return []
     while len(buckets) > limit:
         proposals = {}  # rolled_key -> [sum_count, [original_keys...]]
         for key, count in buckets.items():
@@ -1394,7 +1444,9 @@ def summarize_focus_areas(paths, limit=None):
             buckets.pop(k)
         buckets[winner_key] = buckets.get(winner_key, 0) + winner_count
     ranked = sorted(buckets.items(), key=lambda kv: (-kv[1], kv[0]))
-    return [k for k, _ in ranked[:limit]]
+    ranked = _drop_low_weight(ranked)
+    result = [k for k, _ in ranked[:limit]]
+    return _dedup_parent_child(result)
 
 
 # Number of recent commits whose touched files contribute to the "focus area"
@@ -1405,19 +1457,22 @@ def summarize_focus_areas(paths, limit=None):
 RECENT_COMMITS_FOR_FOCUS = 10
 
 
-def _files_in_recent_commits(repo_root, count):
-    """Files touched by the last `count` non-merge commits on HEAD."""
-    out = git_lines(
-        [
-            "log",
-            f"-n{count}",
-            "--no-merges",
-            "--name-only",
-            "--pretty=format:",
-        ],
-        cwd=repo_root,
-        check=False,
-    )
+def _files_in_recent_commits(repo_root, count, base_ref=None):
+    """Files touched by recent non-merge commits on the current branch.
+
+    When a default base is known, bound the range to ``base..HEAD`` so noisy
+    commits already merged into the base branch do not pollute focus areas.
+    """
+    cmd = [
+        "log",
+        f"-n{count}",
+        "--no-merges",
+        "--name-only",
+        "--pretty=format:",
+    ]
+    if base_ref:
+        cmd.append(f"{base_ref}..HEAD")
+    out = git_lines(cmd, cwd=repo_root, check=False)
     seen = []
     seen_set = set()
     for line in out:
@@ -1432,9 +1487,8 @@ def collect_git_facts(repo_root, branch_name, _storage_root=None):
     working_tree_files = git_lines(["diff", "--name-only"], cwd=repo_root)
     staged_files = git_lines(["diff", "--cached", "--name-only"], cwd=repo_root)
     untracked_files = git_lines(["ls-files", "--others", "--exclude-standard"], cwd=repo_root)
-    recent_commit_files = _files_in_recent_commits(repo_root, RECENT_COMMITS_FOR_FOCUS)
-
     default_base = detect_default_base(repo_root)
+    recent_commit_files = _files_in_recent_commits(repo_root, RECENT_COMMITS_FOR_FOCUS, default_base)
 
     all_paths = sorted(set(working_tree_files + staged_files + untracked_files + recent_commit_files))
     return {
@@ -1456,28 +1510,29 @@ def merged_focus_areas(new_paths, existing, limit=None):
     tree signal.
 
     Algorithm (matches user's mental model — "specific signals over wide
-    parents, stale entries kept ranked low until limit prunes them"):
+    parents; stale entries disappear once current git facts no longer cover
+    them"):
 
       1. Internally dedupe `existing`: when a wider parent dir (e.g. `apps`)
-         coexists with its specific descendant (e.g. `apps/x/y/prompts`),
-         drop the wider parent. The wider parent is almost always a leftover
-         from an earlier roll-up that swallowed too much; the specific
-         descendants carry the real signal.
+         coexists with either an existing or freshly-derived specific
+         descendant (e.g. `apps/x/y/prompts`), drop the wider parent. The wider
+         parent is almost always a leftover from an earlier roll-up that
+         swallowed too much; the specific descendants carry the real signal.
       2. Score every surviving existing dir by how many `new_paths` it
-         actually covers (0 means stale, e.g. `.vscode` after a one-shot
-         IDE write — but we keep it in the ranking, only the final limit
-         truncation prunes it from the bottom).
-      3. Compute `uncovered` = paths not under any surviving existing dir.
+         actually covers. 0 means stale, e.g. `.vscode` after a one-shot IDE
+         write; stale entries are not carried forward.
+      3. Compute `uncovered` = paths not under any active existing dir.
       4. Roll up the uncovered paths' immediate parents into ≤ remaining
          budget buckets, **forbidding roll-up into any ancestor of an
          existing dir** so the output cannot regenerate the over-wide
          parent we just removed in step 1.
-      5. Merge existing weights with the rolled-up uncovered buckets,
-         sort by weight desc, truncate to `limit`. Stale 0-weight entries
-         naturally sit at the bottom and get culled when buckets > limit.
+      5. Merge active existing weights with the rolled-up uncovered buckets,
+         sort by weight desc, truncate to `limit`.
     """
     if limit is None:
         limit = FOCUS_AREA_LIMIT
+    existing = [d for d in existing
+                if "/" in d and not _should_exclude_path(d)]
     if not existing:
         return summarize_focus_areas(new_paths, limit=limit)
 
@@ -1486,24 +1541,31 @@ def merged_focus_areas(new_paths, existing, limit=None):
             return "/" not in path
         return path == dir_ or path.startswith(dir_ + "/")
 
+    fresh_focus = summarize_focus_areas(new_paths, limit=limit)
+
     def _drop_wider_parents(items):
-        items = list(dict.fromkeys(items))  # dedupe preserving order
-        return [d for d in items if not any(other != d and _is_under(other, d) for other in items)]
+        items = [d for d in dict.fromkeys(items) if d != "."]  # dedupe preserving order
+        comparison_items = items + fresh_focus
+        return [d for d in items if not any(other != d and _is_under(other, d) for other in comparison_items)]
 
     # (1) Drop wider parent entries inside existing.
     deduped_existing = _drop_wider_parents(existing)
 
-    # (2) Real coverage weight per surviving existing dir.
+    # (2) Real coverage weight per surviving existing dir. Drop stale existing
+    # dirs before computing uncovered paths or slot budget; otherwise stale
+    # manifest entries still force new hot spots to roll up too far.
     existing_weights = {d: sum(1 for p in new_paths if _is_under(p, d)) for d in deduped_existing}
+    active_existing_weights = {d: w for d, w in existing_weights.items() if w > 0}
 
-    # (3) Paths not yet covered by any existing dir.
-    uncovered = [p for p in new_paths if not any(_is_under(p, d) for d in deduped_existing)]
+    # (3) Paths not yet covered by any active existing dir.
+    active_existing_dirs = set(active_existing_weights)
+    uncovered = [p for p in new_paths if not any(_is_under(p, d) for d in active_existing_dirs)]
 
     # (4) Forbidden roll-up targets = any ancestor of a surviving existing
     # dir. Without this guard the roll-up of `uncovered` could produce a
     # parent like `apps` and we'd be back where we started.
     forbidden_ancestors = set()
-    for d in deduped_existing:
+    for d in active_existing_dirs:
         if d in ("", "."):
             continue
         parent = Path(d).parent
@@ -1517,11 +1579,13 @@ def merged_focus_areas(new_paths, existing, limit=None):
             parent = parent.parent
 
     # Reserve slots for existing entries; uncovered fills the rest.
-    remaining_budget = max(1, limit - len(existing_weights))
+    remaining_budget = max(1, limit - len(active_existing_weights))
 
     new_buckets = Counter()
     for p in uncovered:
-        new_buckets[_initial_parent(p)] += 1
+        key = _initial_parent(p)
+        if key is not None and not _should_exclude_path(p):
+            new_buckets[key] += 1
 
     while len(new_buckets) > remaining_budget:
         proposals = {}
@@ -1558,16 +1622,10 @@ def merged_focus_areas(new_paths, existing, limit=None):
     #   - new_quota      = floor(limit/2) → reserved for fresh buckets
     #   - either side can borrow unused slots from the other (so we never
     #     leave a slot empty just to enforce the partition).
-    #   - stale existing (weight=0) is a fallback that only fills slots left
-    #     after both quotas are settled — they ride at the bottom and get
-    #     pruned naturally.
     existing_active = sorted(
-        ((d, w) for d, w in existing_weights.items() if w > 0),
+        active_existing_weights.items(),
         key=lambda kv: (-kv[1], kv[0]),
     )
-    existing_stale = sorted(
-        (d for d, w in existing_weights.items() if w == 0),
-    )
     new_items = sorted(new_buckets.items(), key=lambda kv: (-kv[1], kv[0]))
 
     existing_quota = (limit + 1) // 2  # ceil(limit/2)
@@ -1584,26 +1642,26 @@ def merged_focus_areas(new_paths, existing, limit=None):
     if new_overflow > 0:
         existing_take.extend(existing_active[existing_quota:existing_quota + new_overflow])
 
-    final = []
+    selected = []
     seen = set()
-    for d, _ in existing_take + new_take:
-        if d in seen:
-            continue
-        seen.add(d)
-        final.append(d)
-    for d in existing_stale:
-        if len(final) >= limit:
-            break
+    for d, weight in existing_take + new_take:
         if d in seen:
             continue
         seen.add(d)
-        final.append(d)
-    return final[:limit]
+        selected.append((d, weight))
+    selected.sort(key=lambda kv: (-kv[1], kv[0]))
+    selected = _drop_low_weight(selected)
+    result = [d for d, _ in selected[:limit]]
+    return _dedup_parent_child(result)
 
 
 def build_auto_block(facts):
     base_line = facts["default_base"] or "未检测到 origin/HEAD"
     head_line = facts["last_seen_head"] or "尚未检测到 HEAD"
+    if facts["default_base"]:
+        history_cmd = f"git log --oneline -n {RECENT_COMMITS_FOR_FOCUS} --no-merges {facts['default_base']}..HEAD"
+    else:
+        history_cmd = f"git log --oneline -n {RECENT_COMMITS_FOR_FOCUS} --no-merges"
     focus_lines = render_bullets(facts["focus_areas"], empty_text="- 当前未检测到改动目录", wrap_code=True)
     scope_lines = render_bullets(
         [f"{item['scope']} ({item['files']} files)" for item in facts["scope_summary"]],
@@ -1620,7 +1678,7 @@ def build_auto_block(facts):
         "#### 顶层改动范围\n\n"
         f"{scope_lines}\n\n"
         "#### 按需查看提交历史\n\n"
-        f"- `git log --oneline -n {RECENT_COMMITS_FOR_FOCUS} --no-merges`\n"
+        f"- `{history_cmd}`\n"
         "- `git diff --name-only`\n"
     )
 

package/lib/dev_memory_context.py

@@ -103,6 +103,33 @@ def command_sync(args):
     print(json.dumps(payload, ensure_ascii=False, indent=2))
 
 
+def command_injection_preview(args):
+    """Render the SessionStart injection context for a given repo_key + branch,
+    without needing an actual git working tree. Used by the UI panel."""
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts" / "hooks"))
+    from _common import _build_context_from_assets  # noqa: E402
+    from dev_memory_common import asset_paths as _asset_paths  # noqa: E402
+
+    storage_root = Path(args.context_dir) if args.context_dir else Path.home() / ".dev-memory" / "repos"
+    repo_dir = storage_root / args.repo_key
+    branch_dir = repo_dir / "branches" / args.branch.replace("/", "__")
+
+    if not branch_dir.exists():
+        print(json.dumps({"error": f"branch dir not found: {branch_dir}"}, ensure_ascii=False))
+        return 1
+
+    paths = _asset_paths(repo_dir, branch_dir)
+    assets = {
+        "repo_dir": repo_dir,
+        "branch_dir": branch_dir,
+        "branch_name": args.branch,
+        "paths": paths,
+    }
+    context = _build_context_from_assets(assets, full=True)
+    print(json.dumps({"context": context or ""}, ensure_ascii=False))
+    return 0
+
+
 def main():
     parser = argparse.ArgumentParser(description="Read or refresh repo+branch development assets.")
     subparsers = parser.add_subparsers(dest="command", required=True)
@@ -113,12 +140,19 @@ def main():
         sub.add_argument("--context-dir", help="User-home storage root. Defaults to ~/.dev-memory/repos")
         sub.add_argument("--branch", help="Branch name. Defaults to the current checked-out branch")
 
+    preview_sub = subparsers.add_parser("injection-preview")
+    preview_sub.add_argument("--repo-key", required=True, help="Repo key (directory name under storage root)")
+    preview_sub.add_argument("--branch", required=True, help="Branch name (original, with slashes)")
+    preview_sub.add_argument("--context-dir", help="Storage root. Defaults to ~/.dev-memory/repos")
+
     args = parser.parse_args()
     try:
         if args.command == "show":
             command_show(args)
-        else:
+        elif args.command == "sync":
             command_sync(args)
+        elif args.command == "injection-preview":
+            return command_injection_preview(args)
     except Exception as exc:
         print(f"ERROR: {exc}", file=sys.stderr)
         return 1

package/lib/dev_memory_graduate.py

@@ -10,6 +10,8 @@ the heuristic missed, but the primary signal is pending-promotion.
 """
 
 import argparse
+import contextlib
+import fcntl
 import json
 import sys
 from datetime import datetime, timezone
@@ -130,21 +132,11 @@ def _apply_entries(target_path, entries):
     return n
 
 
-def command_apply(args):
-    if detect_no_git_mode(args.repo):
-        print(json.dumps({"error": "no-git mode: graduate has nothing to archive"}, ensure_ascii=False))
-        return 1
-
-    repo_root, branch_name, branch_key, _, repo_key, repo_dir, branch_dir = get_branch_paths(args.repo, args.context_dir, args.branch)
-
-    if not branch_dir.exists():
-        print(json.dumps({"error": f"branch memory not initialized: {branch_dir}"}, ensure_ascii=False))
-        return 1
-
-    harvest = read_json(Path(args.harvest_file))
+def _load_harvest(harvest_file):
+    harvest_path = Path(harvest_file)
+    harvest = read_json(harvest_path)
     if not harvest:
-        print(json.dumps({"error": f"harvest file empty or missing: {args.harvest_file}"}, ensure_ascii=False))
-        return 1
+        raise ValueError(f"harvest file empty or missing: {harvest_file}")
 
     # Reject unknown top-level keys explicitly. The most common failure mode
     # is a pre-v2 harvest.json still using repo_context / repo_sources —
@@ -160,13 +152,74 @@ def command_apply(args):
                 " (v1 schema? repo_context → repo_decisions or repo_glossary; "
                 "repo_sources → repo_glossary; see references/harvest-schema.md)"
             )
-        print(
-            json.dumps(
-                {"error": f"unknown harvest key(s): {unknown_keys}{legacy_hint}"},
-                ensure_ascii=False,
+        raise ValueError(f"unknown harvest key(s): {unknown_keys}{legacy_hint}")
+    return harvest
+
+
+def _resolve_apply_context(args):
+    if detect_no_git_mode(args.repo):
+        raise ValueError("no-git mode: graduate has nothing to archive")
+
+    repo_root, branch_name, branch_key, _, repo_key, repo_dir, branch_dir = get_branch_paths(
+        args.repo,
+        args.context_dir,
+        args.branch,
+    )
+    if not branch_dir.exists():
+        raise ValueError(f"branch memory not initialized: {branch_dir}")
+
+    return {
+        "repo_root": repo_root,
+        "branch_name": branch_name,
+        "branch_key": branch_key,
+        "repo_key": repo_key,
+        "repo_dir": repo_dir,
+        "branch_dir": branch_dir,
+    }
+
+
+def _graduate_apply_lock_path(repo_dir):
+    return Path(repo_dir) / "jobs" / "graduate-apply.lock"
+
+
+@contextlib.contextmanager
+def _graduate_apply_queue(repo_dir):
+    """Serialize graduate apply per repo memory directory.
+
+    Pre-flight validation happens before this context. The lock only protects
+    repo-shared writes + branch archive moves, so independent invocations can
+    still fail fast on bad harvest files before waiting behind a long apply.
+    """
+    lock_path = _graduate_apply_lock_path(repo_dir)
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open("a+", encoding="utf-8") as lock_fh:
+        waited = False
+        try:
+            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            waited = True
+            print(
+                f"[dev-memory][graduate] another apply is running; queued on {lock_path}",
+                file=sys.stderr,
             )
-        )
-        return 1
+            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
+        try:
+            yield waited
+        finally:
+            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_UN)
+
+
+def _apply_validated(context, harvest, *, queue_waited=False):
+    repo_root = context["repo_root"]
+    branch_name = context["branch_name"]
+    branch_key = context["branch_key"]
+    repo_dir = context["repo_dir"]
+    branch_dir = context["branch_dir"]
+
+    # The branch may have been archived by an earlier queued apply while this
+    # process was waiting. Re-check inside the critical section before writing.
+    if not branch_dir.exists():
+        raise ValueError(f"branch memory not initialized: {branch_dir}")
 
     paths = asset_paths(repo_dir, branch_dir)
 
@@ -226,10 +279,20 @@ def command_apply(args):
         "harvested_total": total,
         "archive_summary": str((archive_dst or branch_dir) / "archive_summary.md"),
         "archived_to": str(archive_dst) if archive_dst else None,
+        "queue_waited": queue_waited,
     }, ensure_ascii=False, indent=2))
     return 0
 
 
+def command_apply(args):
+    # Pre-flight first: bad input should return immediately even if another
+    # session is currently applying a valid graduate harvest.
+    context = _resolve_apply_context(args)
+    harvest = _load_harvest(args.harvest_file)
+    with _graduate_apply_queue(context["repo_dir"]) as waited:
+        return _apply_validated(context, harvest, queue_waited=waited)
+
+
 def command_index(args):
     if detect_no_git_mode(args.repo):
         print(json.dumps({"error": "no-git mode: no archive index"}, ensure_ascii=False))