dev-memory-cli 0.18.2 → 0.19.2

package/lib/dev_memory_read.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from dev_memory_common import (  # noqa: E402
+    DEV_MEMORY_ID_FILE,
+    LEGACY_ID_FILE,
+    MANAGED_FILES,
+    asset_paths,
+    detect_no_git_mode,
+    get_branch_paths,
+    read_json,
+)
+
+
+BRANCH_FILE_KEYS = (
+    "overview",
+    "progress",
+    "decisions",
+    "risks",
+    "glossary",
+    "unsorted",
+    "pending_promotion",
+    "log",
+    "manifest",
+)
+
+REPO_FILE_KEYS = (
+    "repo_overview",
+    "repo_decisions",
+    "repo_glossary",
+    "repo_log",
+    "repo_manifest",
+)
+
+READ_ORDER = (
+    "glossary",
+    "decisions",
+    "risks",
+    "overview",
+    "repo_decisions",
+    "repo_glossary",
+    "repo_overview",
+    "unsorted",
+    "pending_promotion",
+    "log",
+)
+
+
+def _resolve_paths(repo, context_dir=None, branch=None):
+    repo_path = Path(repo).expanduser().resolve()
+    if detect_no_git_mode(repo_path) and not (
+        (repo_path / DEV_MEMORY_ID_FILE).exists()
+        or (repo_path / LEGACY_ID_FILE).exists()
+    ):
+        raise RuntimeError(
+            "no-git memory is not initialized; read refuses to create a .dev-memory-id. "
+            "Initialize by writing via capture/setup first, or pass a Git repo path."
+        )
+    repo_root, branch_name, branch_key, storage_root, repo_key, repo_dir, branch_dir = get_branch_paths(
+        repo, context_dir, branch
+    )
+    paths = asset_paths(repo_dir, branch_dir)
+    return {
+        "repo_root": repo_root,
+        "branch_name": branch_name,
+        "branch_key": branch_key,
+        "storage_root": storage_root,
+        "repo_key": repo_key,
+        "repo_dir": repo_dir,
+        "branch_dir": branch_dir,
+        "paths": paths,
+    }
+
+
+def _existing_branch_dirs(repo_dir):
+    branches_dir = repo_dir / "branches"
+    if not branches_dir.exists():
+        return []
+    result = []
+    for path in sorted(branches_dir.iterdir(), key=lambda p: p.name):
+        if not path.is_dir() or path.name == "_archived":
+            continue
+        manifest = read_json(path / "manifest.json")
+        result.append(
+            {
+                "branch_key": path.name,
+                "branch": manifest.get("branch") or path.name.replace("__", "/"),
+                "path": str(path),
+            }
+        )
+    return result
+
+
+def _existing_files(paths, keys):
+    files = {}
+    for key in keys:
+        path = paths[key]
+        files[key] = {
+            "path": str(path),
+            "exists": path.exists(),
+        }
+    return files
+
+
+def _memory_files_for_dir(memory_dir):
+    for file_name in MANAGED_FILES:
+        path = memory_dir / file_name
+        if path.exists() and path.is_file():
+            yield path
+
+
+def _dedupe_paths(paths):
+    seen = set()
+    result = []
+    for path in paths:
+        resolved = path.resolve()
+        if resolved in seen:
+            continue
+        seen.add(resolved)
+        result.append(path)
+    return result
+
+
+def _scope_files(resolved, scope):
+    paths = resolved["paths"]
+    repo_dir = resolved["repo_dir"]
+    branch_dir = resolved["branch_dir"]
+    files = []
+
+    if scope in ("branch", "current"):
+        files.extend(paths[key] for key in BRANCH_FILE_KEYS)
+    if scope in ("repo", "current"):
+        files.extend(paths[key] for key in REPO_FILE_KEYS)
+    if scope == "all-branches":
+        files.extend(paths[key] for key in REPO_FILE_KEYS)
+        branches_dir = repo_dir / "branches"
+        if branches_dir.exists():
+            for child in sorted(branches_dir.iterdir(), key=lambda p: p.name):
+                if child.is_dir() and child.name != "_archived":
+                    files.extend(_memory_files_for_dir(child))
+    if scope == "archived":
+        archived_dir = repo_dir / "branches" / "_archived"
+        if archived_dir.exists():
+            for child in sorted(archived_dir.iterdir(), key=lambda p: p.name):
+                if child.is_dir():
+                    files.extend(_memory_files_for_dir(child))
+    if scope == "all":
+        files.extend(paths[key] for key in REPO_FILE_KEYS)
+        branches_dir = repo_dir / "branches"
+        if branches_dir.exists():
+            for child in sorted(branches_dir.rglob("*"), key=lambda p: p.as_posix()):
+                if child.is_dir() and child.name != "_archived":
+                    files.extend(_memory_files_for_dir(child))
+
+    return [p for p in _dedupe_paths(files) if p.exists() and p.is_file()]
+
+
+def _make_matchers(queries, *, regex=False, case_sensitive=False):
+    if not queries:
+        raise ValueError("pass at least one --query")
+    if regex:
+        flags = 0 if case_sensitive else re.IGNORECASE
+        return [(q, re.compile(q, flags)) for q in queries]
+    if case_sensitive:
+        return [(q, q) for q in queries]
+    return [(q, q.lower()) for q in queries]
+
+
+def _line_matches(line, matchers, *, regex=False, case_sensitive=False):
+    haystack = line if case_sensitive else line.lower()
+    matched = []
+    for raw, matcher in matchers:
+        if regex:
+            if matcher.search(line):
+                matched.append(raw)
+        elif matcher in haystack:
+            matched.append(raw)
+    return matched
+
+
+def _context_lines(lines, line_no, radius):
+    if radius <= 0:
+        return []
+    start = max(1, line_no - radius)
+    end = min(len(lines), line_no + radius)
+    result = []
+    for current in range(start, end + 1):
+        if current == line_no:
+            continue
+        result.append({"line": current, "text": lines[current - 1]})
+    return result
+
+
+def command_show(args):
+    resolved = _resolve_paths(args.repo, args.context_dir, args.branch)
+    paths = resolved["paths"]
+    payload = {
+        "repo_root": str(resolved["repo_root"]),
+        "repo_key": resolved["repo_key"],
+        "branch": resolved["branch_name"],
+        "branch_key": resolved["branch_key"],
+        "storage_root": str(resolved["storage_root"]),
+        "repo_dir": str(resolved["repo_dir"]),
+        "branch_dir": str(resolved["branch_dir"]),
+        "repo_exists": resolved["repo_dir"].exists(),
+        "branch_exists": resolved["branch_dir"].exists(),
+        "recommended_read_order": [
+            {"key": key, "path": str(paths[key]), "exists": paths[key].exists()}
+            for key in READ_ORDER
+            if key in paths
+        ],
+        "branch_files": _existing_files(paths, BRANCH_FILE_KEYS),
+        "repo_files": _existing_files(paths, REPO_FILE_KEYS),
+        "existing_branches": _existing_branch_dirs(resolved["repo_dir"]),
+    }
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def command_search(args):
+    resolved = _resolve_paths(args.repo, args.context_dir, args.branch)
+    matchers = _make_matchers(args.query, regex=args.regex, case_sensitive=args.case_sensitive)
+    files = _scope_files(resolved, args.scope)
+    hits = []
+
+    for path in files:
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except UnicodeDecodeError:
+            continue
+        for idx, line in enumerate(lines, start=1):
+            matched_queries = _line_matches(
+                line,
+                matchers,
+                regex=args.regex,
+                case_sensitive=args.case_sensitive,
+            )
+            if not matched_queries:
+                continue
+            hits.append(
+                {
+                    "path": str(path),
+                    "line": idx,
+                    "text": line,
+                    "matched_queries": matched_queries,
+                    "context": _context_lines(lines, idx, args.context_lines),
+                }
+            )
+            if len(hits) >= args.max_hits:
+                break
+        if len(hits) >= args.max_hits:
+            break
+
+    payload = {
+        "repo_root": str(resolved["repo_root"]),
+        "repo_key": resolved["repo_key"],
+        "branch": resolved["branch_name"],
+        "branch_key": resolved["branch_key"],
+        "repo_dir": str(resolved["repo_dir"]),
+        "branch_dir": str(resolved["branch_dir"]),
+        "scope": args.scope,
+        "queries": args.query,
+        "regex": args.regex,
+        "searched_files": [str(p) for p in files],
+        "hit_count": len(hits),
+        "hits": hits,
+    }
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Locate and search dev-memory files for the current repo/branch without scanning global memory."
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    show = subparsers.add_parser("show", help="Show authoritative memory paths for a repo/branch.")
+    show.add_argument("--repo", default=".", help="Path inside the target Git repository")
+    show.add_argument("--context-dir", help="User-home storage root. Defaults to ~/.dev-memory/repos")
+    show.add_argument("--branch", help="Branch name. Defaults to the current checked-out branch")
+
+    search = subparsers.add_parser("search", help="Search memory files under the resolved repo memory directory.")
+    search.add_argument("--repo", default=".", help="Path inside the target Git repository")
+    search.add_argument("--context-dir", help="User-home storage root. Defaults to ~/.dev-memory/repos")
+    search.add_argument("--branch", help="Branch name. Defaults to the current checked-out branch")
+    search.add_argument(
+        "--scope",
+        choices=("current", "branch", "repo", "all-branches", "archived", "all"),
+        default="current",
+        help="Which memory files to search. Defaults to current branch + repo shared layer.",
+    )
+    search.add_argument("--query", action="append", required=True, help="Literal query. Repeat for OR matching.")
+    search.add_argument("--regex", action="store_true", help="Treat --query values as Python regex patterns.")
+    search.add_argument("--case-sensitive", action="store_true")
+    search.add_argument("--context-lines", type=int, default=1, help="Neighboring lines to include around each hit.")
+    search.add_argument("--max-hits", type=int, default=80)
+
+    args = parser.parse_args()
+    try:
+        if args.command == "show":
+            command_show(args)
+        else:
+            command_search(args)
+    except Exception as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/lib/dev_memory_setup.py

@@ -102,8 +102,6 @@ def command_init(args):
 
 _SETUP_KIND_TO_TARGET = {
     "decision": ("decisions", "关键决策与原因"),
-    "progress": ("progress", "当前进展"),
-    "next": ("progress", "下一步"),
     "risk": ("risks", "阻塞与注意点"),
     "glossary": ("glossary", "当前有效上下文"),
     "source": ("glossary", "分支源资料入口"),

package/lib/dev_memory_summary.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+def _read_json(path):
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def _text_from_content(content):
+    if isinstance(content, str):
+        return content
+    if not isinstance(content, list):
+        return ""
+    parts = []
+    for item in content:
+        if not isinstance(item, dict):
+            continue
+        typ = item.get("type")
+        if typ in ("tool_use", "tool_result", "function_call", "function_call_output"):
+            continue
+        text = item.get("text")
+        if isinstance(text, str):
+            parts.append(text)
+    return "\n".join(parts).strip()
+
+
+def _extract_claude(obj):
+    typ = obj.get("type")
+    if typ not in ("user", "assistant"):
+        return None
+    msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
+    role = msg.get("role") or typ
+    text = _text_from_content(msg.get("content"))
+    if not text:
+        return None
+    return {
+        "source": "claude",
+        "role": role,
+        "timestamp": obj.get("timestamp"),
+        "uuid": obj.get("uuid"),
+        "text": text,
+    }
+
+
+def _extract_codex(obj):
+    if obj.get("type") != "response_item":
+        return None
+    payload = obj.get("payload")
+    if not isinstance(payload, dict):
+        return None
+    if payload.get("type") != "message":
+        return None
+    role = payload.get("role")
+    if role not in ("user", "assistant"):
+        return None
+    text = _text_from_content(payload.get("content"))
+    if not text:
+        return None
+    return {
+        "source": "codex",
+        "role": role,
+        "timestamp": obj.get("timestamp"),
+        "text": text,
+    }
+
+
+def _iter_core_messages(transcript_path):
+    if not transcript_path:
+        return []
+    path = Path(transcript_path).expanduser()
+    if not path.exists():
+        return []
+    out = []
+    with path.open(encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except Exception:
+                continue
+            msg = _extract_claude(obj) or _extract_codex(obj)
+            if msg:
+                out.append(msg)
+    return out
+
+
+def _truncate(text, max_chars):
+    text = (text or "").strip()
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 3].rstrip() + "..."
+
+
+def _is_nonsemantic_user_text(text):
+    stripped = (text or "").strip()
+    if not stripped:
+        return True
+    markers = (
+        "<local-command-caveat>",
+        "<command-name>",
+        "<command-message>",
+        "<command-args>",
+        "Your tool call was malformed",
+    )
+    return any(marker in stripped for marker in markers)
+
+
+def _memory_file(path, max_chars, name=None):
+    p = Path(path)
+    if not p.exists():
+        return None
+    text = p.read_text(encoding="utf-8")
+    item = {
+        "name": name or p.name,
+        "content": _truncate(text, max_chars),
+    }
+    if len(text) > max_chars:
+        item["truncated"] = True
+    return item
+
+
+def _summary_job(job):
+    transcript_state = job.get("transcript_state") if isinstance(job.get("transcript_state"), dict) else {}
+    previous_job = job.get("previous_job") if isinstance(job.get("previous_job"), dict) else {}
+    return {
+        "repo_root": job.get("repo_root"),
+        "transcript_state": {
+            key: transcript_state.get(key)
+            for key in ("size", "mtime_ms")
+            if transcript_state.get(key) is not None
+        },
+        "previous_processed": previous_job.get("processed") if isinstance(previous_job.get("processed"), dict) else None,
+    }
+
+
+def extract_core_payload(
+    job,
+    *,
+    max_messages=40,
+    max_message_chars=2000,
+    max_memory_chars=6000,
+    since_size=0,
+    include_message_metadata=False,
+):
+    branch_dir = Path(job["branch_dir"])
+    repo_dir = Path(job["repo_dir"])
+    memory_paths = [
+        ("branch/progress.md", branch_dir / "progress.md"),
+        ("branch/risks.md", branch_dir / "risks.md"),
+        ("branch/decisions.md", branch_dir / "decisions.md"),
+        ("branch/glossary.md", branch_dir / "glossary.md"),
+        ("branch/overview.md", branch_dir / "overview.md"),
+        ("repo/decisions.md", repo_dir / "repo" / "decisions.md"),
+        ("repo/glossary.md", repo_dir / "repo" / "glossary.md"),
+    ]
+    messages = _iter_core_messages(job.get("transcript_path"))
+    if since_size:
+        # JSONL is line-oriented but byte offsets can land mid-line. Keep this
+        # option conservative for now: expose cursor metadata and let workers
+        # use recent-tail until a precise offset reader is needed.
+        pass
+    messages = [m for m in messages if not _is_nonsemantic_user_text(m["text"])]
+    recent = messages[-max_messages:]
+    core_messages = []
+    for m in recent:
+        item = {
+            "role": m["role"],
+            "text": _truncate(m["text"], max_message_chars),
+        }
+        if include_message_metadata:
+            item = {**m, "text": item["text"]}
+        core_messages.append(item)
+
+    return {
+        "job": _summary_job(job),
+        "existing_memory": [
+            item
+            for item in (
+                _memory_file(path, max_memory_chars, name=name)
+                for name, path in memory_paths
+            )
+            if item is not None
+        ],
+        "core_messages": core_messages,
+        "stats": {
+            "core_message_count": len(messages),
+            "returned_core_message_count": len(recent),
+        },
+    }
+
+
+def command_extract_core(args):
+    job = _read_json(args.job)
+    payload = extract_core_payload(
+        job,
+        max_messages=args.max_messages,
+        max_message_chars=args.max_message_chars,
+        max_memory_chars=args.max_memory_chars,
+        since_size=args.since_size,
+        include_message_metadata=args.include_message_metadata,
+    )
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Session summary helper commands.")
+    sub = parser.add_subparsers(dest="command", required=True)
+    p = sub.add_parser("extract-core", help="Extract core transcript messages and current memory for a summary job")
+    p.add_argument("job", help="Path to a session-summary pending job JSON")
+    p.add_argument("--max-messages", type=int, default=40)
+    p.add_argument("--max-message-chars", type=int, default=2000)
+    p.add_argument("--max-memory-chars", type=int, default=6000)
+    p.add_argument("--since-size", type=int, default=0, help="Reserved cursor hint for future byte-offset extraction")
+    p.add_argument(
+        "--include-message-metadata",
+        action="store_true",
+        help="Include source/timestamp/uuid fields in core_messages for debugging",
+    )
+
+    args = parser.parse_args()
+    if args.command == "extract-core":
+        command_extract_core(args)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/lib/ui-app.html

@@ -840,6 +840,10 @@ function renderContent() {
     content.appendChild(bs);
   }
 
+  var previewBtn = el("button", { class: "icon-btn", style: "margin-bottom: 16px;" }, "👁 注入预览");
+  previewBtn.onclick = function () { openInjectionPreview(repo.key, cur.name); };
+  content.appendChild(previewBtn);
+
   var branchMdFiles = cur.files.filter(function (f) { return f.name.endsWith(".md"); });
   if (branchMdFiles.length === 0) {
     content.appendChild(el("div", { class: "empty-state" }, "该分支暂无记忆文件"));
@@ -989,6 +993,43 @@ function closeModal() {
   modalState.editing = false;
 }
 
+function openInjectionPreview(repoKey, branchName) {
+  modalState.relPath = null;
+  modalState.text = "";
+  modalState.editing = false;
+  q("#modalTitle").textContent = "注入预览 — " + branchName;
+  q("#modalEdit").hidden = true;
+  q("#modalSave").hidden = true;
+  q("#modalCancel").hidden = true;
+  setModalStatus("");
+  var body = q("#modalBody");
+  body.innerHTML = "";
+  body.appendChild(el("span", { class: "loading" }, "生成注入预览…"));
+  q("#modal").classList.add("open");
+
+  fetch("/api/injection-preview?repo=" + encodeURIComponent(repoKey) + "&branch=" + encodeURIComponent(branchName))
+    .then(function (r) { return r.json(); })
+    .then(function (data) {
+      body.innerHTML = "";
+      if (data.error) {
+        body.appendChild(el("pre", { class: "raw" }, "错误：" + data.error));
+        return;
+      }
+      var text = data.context || "(空)";
+      var pre = document.createElement("pre");
+      pre.className = "raw";
+      pre.style.whiteSpace = "pre-wrap";
+      pre.style.wordBreak = "break-word";
+      pre.textContent = text;
+      body.appendChild(pre);
+      setModalStatus(text.length + " 字符", "success");
+    })
+    .catch(function (err) {
+      body.innerHTML = "";
+      body.appendChild(el("pre", { class: "raw" }, "请求失败：" + err.message));
+    });
+}
+
 function loadTree() {
   q("#meta").textContent = "加载中…";
   q("#repoList").innerHTML = '<div class="loading">加载中…</div>';

package/lib/ui-server.js

@@ -201,6 +201,42 @@ function writeFileSafely(fullPath, content) {
   };
 }
 
+const CONTEXT_SCRIPT = path.join(__dirname, "dev_memory_context.py");
+
+function runInjectionPreview(repoKey, branch) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      CONTEXT_SCRIPT,
+      "injection-preview",
+      "--repo-key", repoKey,
+      "--branch", branch,
+      "--context-dir", getStorageRoot(),
+    ];
+    const child = spawn(process.env.DEV_MEMORY_PYTHON || "python3", args, {
+      cwd: __dirname,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 15000,
+    });
+    const chunks = [];
+    child.stdout.on("data", (d) => chunks.push(d));
+    let stderr = "";
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+    child.on("close", (code) => {
+      const stdout = Buffer.concat(chunks).toString("utf8");
+      if (code !== 0) {
+        reject(new Error(stderr || `exit ${code}`));
+        return;
+      }
+      try {
+        resolve(JSON.parse(stdout));
+      } catch (e) {
+        reject(new Error(`invalid JSON: ${e.message}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+
 function readAppHtml() {
   return fs.readFileSync(APP_HTML_PATH, "utf8");
 }
@@ -263,6 +299,23 @@ function start({ host = "127.0.0.1", port = 0, openBrowserFlag = true, readOnly
       res.end(JSON.stringify(tree));
       return;
     }
+    if (url.pathname === "/api/injection-preview" && isRead) {
+      const repoKey = url.searchParams.get("repo") || "";
+      const branch = url.searchParams.get("branch") || "";
+      if (!repoKey || !branch) {
+        res.writeHead(400, { "content-type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify({ error: "repo and branch required" }));
+        return;
+      }
+      runInjectionPreview(repoKey, branch).then((data) => {
+        res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(data));
+      }).catch((err) => {
+        res.writeHead(500, { "content-type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify({ error: err.message }));
+      });
+      return;
+    }
     if (url.pathname === "/api/file" && isRead) {
       const rel = url.searchParams.get("path") || "";
       const full = resolveSafePath(rel);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev-memory-cli",
-  "version": "0.18.2",
+  "version": "0.19.2",
   "description": "CLI for dev-memory hooks and repo-local setup (formerly @xluos/dev-assets-cli)",
   "license": "MIT",
   "repository": {