forgexa-cli 1.10.2__tar.gz → 1.10.4__tar.gz

{forgexa_cli-1.10.2 → forgexa_cli-1.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.10.2
+Version: 1.10.4
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.10.2 → forgexa_cli-1.10.4}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.10.2"
+__version__ = "1.10.4"

{forgexa_cli-1.10.2 → forgexa_cli-1.10.4}/forgexa_cli/daemon.py

@@ -376,6 +376,14 @@ except (ImportError, ModuleNotFoundError):
             """
             return os.environ.get("FACTORY_CODEX_SANDBOX", "bypass").strip().lower()
 
+        @property
+        def DAEMON_COMMIT_VERBOSE(self) -> bool:
+            """When true, append Task / Phase / Agent traceability metadata to
+            the commit message footer.  Default false: commits show subject +
+            readable narrative body only — suitable for client-facing repos.
+            """
+            return os.environ.get("DAEMON_COMMIT_VERBOSE", "false").strip().lower() in ("1", "true", "yes")
+
         def get_daemon_workspaces_root(self) -> str:
             root = self.DAEMON_WORKSPACES_ROOT
             if not root:
@@ -396,7 +404,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.10.2"
+DAEMON_VERSION = "1.10.4"
 
 
 def _detect_client_type() -> str:
@@ -648,6 +656,49 @@ class TaskResult:
     git: dict = field(default_factory=dict)
 
 
+def _resolve_git_author(project: dict) -> tuple[str, str]:
+    """Resolve git commit author (name, email) using a 5-tier fallback chain.
+
+    Priority (highest → lowest):
+      0a. Project-member override  (member_git_commit_name/email)
+          Set per-user in project settings; ideal for client-assigned emails
+          (e.g. HP project: keep name, override email to jason.sun@hp.com).
+      0b. Project default          (project_git_commit_name/email)
+          Project-wide fallback for all members who have no individual override.
+      1.  Task triggering user     (triggered_by_git_name/email)
+          The human who submitted or re-triggered the workflow.
+      2.  Runtime owner user       (runtime_owner_git_name/email)
+          The user who registered this daemon (fallback for automated triggers).
+      3.  Hardcoded fallback       ("Forgexa Agent" / "agent@forgexa.net")
+
+    Name and email are resolved **independently**.  This means you can configure
+    only the email override (leave name blank) and the name will still come from
+    the triggered-by user, satisfying "same name, different email" requirements.
+    """
+    def _first_non_empty(*candidates) -> str:
+        for v in candidates:
+            v = (v or "").strip()
+            if v:
+                return v
+        return ""
+
+    name = _first_non_empty(
+        project.get("member_git_commit_name"),
+        project.get("project_git_commit_name"),
+        project.get("triggered_by_git_name"),
+        project.get("runtime_owner_git_name"),
+        "Forgexa Agent",
+    )
+    email = _first_non_empty(
+        project.get("member_git_commit_email"),
+        project.get("project_git_commit_email"),
+        project.get("triggered_by_git_email"),
+        project.get("runtime_owner_git_email"),
+        "agent@forgexa.net",
+    )
+    return name, email
+
+
 # ── Type-aware analysis outputs (inline fallback for standalone daemons) ──
 # Mirrors type_workflow_profiles.py — used when import is unavailable (CLI/Desktop).
 _ANALYSIS_OUTPUTS_BY_TYPE: dict[str, list[str]] = {
@@ -1206,9 +1257,10 @@ class WorkspaceManager:
                 readme = ws_path / "README.md"
                 readme.write_text(f"# {project_key}\n\nInitialized by Forgexa.\n")
                 await self._git("add", ".", cwd=ws_path)
+                _git_name, _git_email = _resolve_git_author(project)
                 await self._git(
-                    "-c", "user.name=Forgexa Agent",
-                    "-c", "user.email=agent@forgexa.net",
+                    "-c", f"user.name={_git_name}",
+                    "-c", f"user.email={_git_email}",
                     "commit", "-m", "Initial commit",
                     cwd=ws_path,
                 )
@@ -4569,9 +4621,10 @@ class RuntimeDaemon:
                                 # Remove physical files
                                 shutil.rmtree(str(dir_to_wipe), ignore_errors=True)
                                 # Commit the wipe so the branch diff is clean
+                                _git_name, _git_email = _resolve_git_author(task.project)
                                 await self._git(
-                                    "-c", "user.name=Forgexa Agent",
-                                    "-c", "user.email=agent@forgexa.net",
+                                    "-c", f"user.name={_git_name}",
+                                    "-c", f"user.email={_git_email}",
                                     "commit", "-m",
                                     f"cleanup: wipe analysis docs in {output_dir_norm} before fresh re-analysis",
                                     cwd=workspace_path,
@@ -5808,13 +5861,15 @@ class RuntimeDaemon:
                 except Exception as msg_err:
                     logger.warning("Failed to build rich commit message: %s — using fallback", msg_err)
                     commit_msg = f"{task.node_type}({task.requirement_key or task.task_id}): {display_title}"
+                _git_name, _git_email = _resolve_git_author(task.project)
                 proc = await asyncio.create_subprocess_exec(
                     "git", "commit", "-m", commit_msg,
                     cwd=str(workspace_path),
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    env={**os.environ, "GIT_AUTHOR_NAME": "Forgexa Agent", "GIT_AUTHOR_EMAIL": "agent@forgexa.net",
-                         "GIT_COMMITTER_NAME": "Forgexa Agent", "GIT_COMMITTER_EMAIL": "agent@forgexa.net"},
+                    env={**os.environ,
+                         "GIT_AUTHOR_NAME": _git_name, "GIT_AUTHOR_EMAIL": _git_email,
+                         "GIT_COMMITTER_NAME": _git_name, "GIT_COMMITTER_EMAIL": _git_email},
                 )
                 await proc.communicate()
                 has_new_commit = True
@@ -5854,7 +5909,7 @@ class RuntimeDaemon:
                 return {"push_error": f"Would push to default branch {current_branch}"}
 
             # ── Push ──
-            push_error = await self._push_branch(workspace_path, project_key)
+            push_error = await self._push_branch(workspace_path, project_key, task=task)
             if push_error:
                 return {"push_error": push_error}
             return {}
@@ -5902,6 +5957,12 @@ class RuntimeDaemon:
                 "deletions": deletions,
             })
 
+        # Enrich top changed files with symbol hints from staged additions.
+        # This lets commit summaries mention the code concept that changed
+        # instead of only repeating file names.
+        for file_info in files[:20]:
+            file_info["symbols"] = await self._extract_staged_file_symbols(cwd, file_info["path"])
+
         proc = await asyncio.create_subprocess_exec(
             "git", "diff", "--cached", "--stat",
             cwd=str(cwd),
@@ -5914,6 +5975,55 @@ class RuntimeDaemon:
 
         return {"files": files, "total_stat": total_stat}
 
+    async def _extract_staged_file_symbols(self, cwd: Path, filepath: str) -> list[str]:
+        """Extract symbol names from staged diff additions for one file.
+
+        The goal is not to fully parse each language. We only need a few
+        high-signal names from common declaration patterns so the commit
+        summary can say what concept changed instead of only which file changed.
+        """
+        patterns = (
+            re.compile(r"^(?:async\s+def|def|class)\s+([A-Za-z_][A-Za-z0-9_]*)"),
+            re.compile(r"^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_][A-Za-z0-9_]*)"),
+            re.compile(r"^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*="),
+            re.compile(r"^(?:export\s+)?interface\s+([A-Za-z_][A-Za-z0-9_]*)"),
+            re.compile(r"^(?:export\s+)?type\s+([A-Za-z_][A-Za-z0-9_]*)\b"),
+        )
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "git", "diff", "--cached", "--unified=0", "--", filepath,
+                cwd=str(cwd),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            out, _ = await asyncio.wait_for(proc.communicate(), timeout=10)
+        except Exception:
+            return []
+
+        seen: set[str] = set()
+        symbols: list[str] = []
+        for raw_line in out.decode(errors="replace").splitlines():
+            if not raw_line.startswith("+") or raw_line.startswith("+++"):
+                continue
+            line = raw_line[1:].strip()
+            if not line:
+                continue
+            for pattern in patterns:
+                match = pattern.match(line)
+                if not match:
+                    continue
+                symbol = match.group(1).strip()
+                if len(symbol) < 2 or symbol in seen:
+                    break
+                seen.add(symbol)
+                symbols.append(symbol)
+                break
+            if len(symbols) >= 4:
+                break
+
+        return symbols
+
     async def _build_auto_commit_message(
         self,
         title: str,
@@ -5923,11 +6033,34 @@ class RuntimeDaemon:
         change_summary: dict,
         workspace_path: Path | None = None,
     ) -> str:
-        """Build a rich, natural-language commit message for daemon auto-commits."""
+        """Build a clean, English-only commit message for daemon auto-commits.
+
+        Format (Claude Code style):
+          <type>(<phase>): <concise english subject — max 72 chars>
+          <blank line>
+          - <specific change bullet 1>
+          - <specific change bullet 2>
+          ...
+          [blank line + Task/Phase/Agent footer only when DAEMON_COMMIT_VERBOSE=true]
+
+        Subject: conventional-commit prefix + title derived from the work-item
+        title (non-ASCII stripped).  A single generic word remnant (e.g. just
+        "implement" left after stripping Chinese) triggers file-path inference.
+
+        Body: bullet-point list describing WHAT changed in each file/group —
+        specific and human-readable like Claude Code commits, never counts or
+        vague summaries.  For analysis/planning, structured insights from
+        analysis.json are used when available.
+
+        Footer (Task / Phase / Agent): only appended when DAEMON_COMMIT_VERBOSE
+        is true (default false).  Useful for internal audit trails but hidden
+        by default so commits look clean to external clients.
+        """
+        import re as _re
+
         files = change_summary.get("files", [])
-        total_stat = change_summary.get("total_stat", "")
 
-        # Determine commit type
+        # ── Determine conventional-commit type ────────────────────────────
         if node_type in ("analysis", "planning", "review"):
             commit_type = "docs"
         elif files and all("test" in f["path"].lower() for f in files):
@@ -5938,51 +6071,481 @@ class RuntimeDaemon:
             for f in files
         ):
             commit_type = "docs"
-        elif "fix" in title.lower():
+        elif "fix" in node_type.lower():
             commit_type = "fix"
         else:
             commit_type = "feat"
 
-        header = f"{commit_type}({node_type}): {title}"
+        # ── Sanitize subject: strip non-ASCII so the subject is always English ──
+        # Work-item titles may be in Chinese or other scripts (user-supplied).
+        # We keep ASCII segments; if nothing meaningful remains we infer a
+        # specific English subject from the changed file paths.
+        sanitized_title = _re.sub(r"[^\x00-\x7F]+", " ", title)
+        sanitized_title = _re.sub(r"\s+", " ", sanitized_title).strip(" -:.")
+
+        # Strip leading requirement key (e.g. "LP-1:" / "AILP-20:") to evaluate
+        # whether the remaining goal phrase has enough content.  The req key
+        # itself will be preserved in the final subject line; we only strip it
+        # here to measure the goal phrase quality.
+        _req_key_match = _re.match(r"(?i)([A-Z]+-\d+)([\s:.\-]+)", sanitized_title)
+        _req_key_prefix = _req_key_match.group(0) if _req_key_match else ""
+        goal_phrase = _re.sub(r"(?i)^[A-Z]+-\d+[\s:.\-]+", "", sanitized_title).strip(" -:.")
+        # Strip common leading phase verbs so we don't repeat "implement implement..."
+        bare_goal = _re.sub(
+            r"^(implement|update|fix|add|refactor|improve|create|build|setup|init|generate|plan|analyze)\s+",
+            "", goal_phrase, flags=_re.IGNORECASE,
+        ).strip()
+        bare_words = set(bare_goal.lower().split()) - {"and", "or", "the", "a", "an", "to", "for"}
+        # Also check if sanitized_title is ONLY a req key (e.g. "LP-1" or "AILP-20:")
+        _only_req_key = bool(_re.fullmatch(r"(?i)[A-Z]+-\d+[\s:.\-]*", sanitized_title.strip()))
+        goal_is_trivial = (
+            len(sanitized_title) < 4
+            or _only_req_key
+            or len(bare_words) == 0
+            # A single remaining word (any word) after stripping phase verbs and
+            # req key is almost always an isolated remnant from a mostly-non-ASCII
+            # title (e.g. "AILP-20: integration" after Chinese stripped)
+            or len(bare_words) <= 1
+        )
+
+        if goal_is_trivial:
+            # Derive a specific subject from changed files; prepend req key if present.
+            # Re-scan the original sanitized_title for a req key with separator.
+            # Note: when title is fully Chinese, sanitized becomes just the req key
+            # like "LP-1" without separator; we still want to prepend it.
+            _req_scan = _re.match(r"(?i)([A-Z]+-\d+)", sanitized_title)
+            req_key_clean = _req_scan.group(1).upper() if _req_scan else ""
+            derived = self._derive_subject_from_files(node_type, files)
+            sanitized_title = f"{req_key_clean}: {derived}" if req_key_clean else derived
+        else:
+            # Preserve case of the req-key prefix (uppercase), lowercase only the goal
+            if _req_key_prefix:
+                req_key_upper = _req_key_match.group(1).upper() + _req_key_match.group(2)
+                goal_lower = goal_phrase[0].lower() + goal_phrase[1:] if goal_phrase else goal_phrase
+                sanitized_title = req_key_upper + goal_lower
+            else:
+                sanitized_title = sanitized_title[0].lower() + sanitized_title[1:]
+
+        header = f"{commit_type}({node_type}): {sanitized_title}"
         if len(header) > 72:
             header = header[:69] + "..."
 
         parts = [header, ""]
 
-        # ── Analysis/planning phase: extract structured insights from analysis.json ──
+        # ── Body: bullet-point list of specific changes (Claude Code style) ──
         if node_type in ("analysis", "planning") and workspace_path:
+            # For analysis/planning: structured insights from analysis.json
+            # give the richest description; fall back to bullet body if missing.
             insights = await self._extract_analysis_insights(files, workspace_path)
             if insights:
                 parts.extend(insights)
                 parts.append("")
+            else:
+                bullets = self._build_bullet_body(node_type, files, workspace_path)
+                if bullets:
+                    parts.extend(bullets)
+                    parts.append("")
+        else:
+            # All other phases: specific bullet points per changed file/group
+            bullets = self._build_bullet_body(node_type, files, workspace_path)
+            if bullets:
+                parts.extend(bullets)
+                parts.append("")
+
+        # ── Footer: traceability metadata (opt-in via DAEMON_COMMIT_VERBOSE) ──
+        # Hidden by default — keeps commits clean for external/client projects.
+        # Set DAEMON_COMMIT_VERBOSE=true to include Task/Phase/Agent in footer.
+        if settings.DAEMON_COMMIT_VERBOSE:
+            parts.append(f"Task: {task_id}")
+            parts.append(f"Phase: {node_type}")
+            parts.append(f"Agent: {agent_type}")
 
-        # ── Group files into readable sections ──
-        sections = self._group_commit_files(files)
-        VERBS = {"A": "Add", "M": "Update", "D": "Remove", "R": "Rename"}
-        for section_name, section_files in sections.items():
-            parts.append(f"{section_name}:")
-            for f in section_files[:15]:
-                verb = VERBS.get(f["status"], "Change")
-                stats = ""
-                if f["additions"] and f["deletions"]:
-                    stats = f" (+{f['additions']} \u2212{f['deletions']})"
-                elif f["additions"]:
-                    stats = f" (+{f['additions']})"
-                elif f["deletions"]:
-                    stats = f" (\u2212{f['deletions']})"
-                parts.append(f"- {verb} {f['path']}{stats}")
-            if len(section_files) > 15:
-                parts.append(f"  ... and {len(section_files) - 15} more files")
-            parts.append("")
-
-        if total_stat:
-            parts.append(total_stat)
-            parts.append("")
-        parts.append(f"Task: {task_id}")
-        parts.append(f"Phase: {node_type}")
-        parts.append(f"Agent: {agent_type}")
-
-        return "\n".join(parts)
+        return "\n".join(parts).rstrip()
+
+    @staticmethod
+    def _is_test_path(path: str) -> bool:
+        p = path.lower()
+        return (
+            "test_" in p or "_test" in p or "/test" in p
+            or p.endswith((".test.ts", ".test.tsx", ".spec.ts", ".spec.tsx", ".test.js"))
+        )
+
+    @staticmethod
+    def _infer_change_topic(files: list[dict], *, include_support: bool = False) -> str:
+        """Infer the main business/topic phrase from changed files.
+
+        This prefers stable domain nouns like "search", "project API key",
+        or "workspace settings" over file-structure words like "service",
+        "routes", or raw test symbols.
+        """
+        noise = {
+            "add", "update", "fix", "implement", "create", "build", "main",
+            "index", "base", "default", "config", "settings", "helper",
+            "helpers", "utility", "utils", "service", "services", "route",
+            "routes", "handler", "handlers", "controller", "controllers",
+            "model", "models", "schema", "schemas", "migration", "migrations",
+            "database", "table", "frontend", "backend", "page", "pages",
+            "component", "components", "view", "views", "panel", "modal",
+            "button", "input", "form", "bar", "card", "docs", "doc",
+            "guide", "readme", "changelog", "tests", "test", "spec",
+            "integration", "regression", "unit", "request", "response",
+            "issue", "require", "rotate", "repair", "stream", "flow",
+        }
+
+        def _humanize_text(text: str) -> str:
+            words = re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", text)
+            words = re.sub(r"[_\-/]+", " ", words)
+            return re.sub(r"\s+", " ", words).strip().lower()
+
+        counts: dict[str, int] = {}
+        order: dict[str, int] = {}
+        ranked_files = sorted(
+            files,
+            key=lambda f: f.get("additions", 0) + f.get("deletions", 0),
+            reverse=True,
+        )
+        for file_info in ranked_files[:12]:
+            path_lower = file_info["path"].lower()
+            if not include_support and (
+                RuntimeDaemon._is_test_path(path_lower) or path_lower.startswith("docs/")
+            ):
+                continue
+            weight = max(1, min(5, (file_info.get("additions", 0) + file_info.get("deletions", 0)) // 30 + 1))
+            stem = file_info["path"].rsplit("/", 1)[-1].rsplit(".", 1)[0]
+            sources = [stem] + list(file_info.get("symbols", []))[:3]
+            for source in sources:
+                for token in _humanize_text(str(source)).split():
+                    if len(token) < 3 or token.startswith("test"):
+                        continue
+                    if token in noise or re.fullmatch(r"[a-z]+\d+", token):
+                        continue
+                    counts[token] = counts.get(token, 0) + weight
+                    order.setdefault(token, len(order))
+
+        if not counts:
+            return ""
+
+        ranked = sorted(counts.items(), key=lambda item: (-item[1], order[item[0]]))
+        top_tokens = [token for token, _ in ranked[:8]]
+        top_set = set(top_tokens)
+
+        if "key" in top_set and "api" in top_set:
+            return "project API key" if "project" in top_set else "API key"
+        if "workspace" in top_set and "settings" in top_set:
+            return "workspace settings"
+        if "user" in top_set and "profile" in top_set:
+            return "user profile"
+        if "access" in top_set and "control" in top_set:
+            return "access control"
+        if "search" in top_set:
+            return "search"
+        if "auth" in top_set or "authentication" in top_set:
+            return "authentication"
+        if "log" in top_set or "logs" in top_set:
+            return "API log" if "api" in top_set else "log"
+
+        first = top_tokens[0]
+        if len(ranked) > 1 and ranked[1][1] >= max(2, ranked[0][1] - 1):
+            second = top_tokens[1]
+            display = {"api": "API", "ui": "UI", "qa": "QA", "jwt": "JWT", "oauth": "OAuth"}
+            return f"{display.get(first, first)} {display.get(second, second)}"
+        display = {"api": "API", "ui": "UI", "qa": "QA", "jwt": "JWT", "oauth": "OAuth"}
+        return display.get(first, first)
+
+    @staticmethod
+    def _derive_subject_from_files(node_type: str, files: list[dict]) -> str:
+        """Infer a specific English subject from changed files.
+
+        The subject should summarize the feature area and the primary change
+        surface, instead of echoing file names or test symbols.
+        """
+        _PHASE_VERBS = {
+            "analysis": "analyze",
+            "planning": "plan",
+            "coding": "implement",
+            "fix": "fix",
+            "bugfix": "fix",
+            "testing": "add tests for",
+            "review": "review",
+            "refactor": "refactor",
+            "documentation": "document",
+            "improvement": "improve",
+        }
+
+        verb = _PHASE_VERBS.get(node_type, "update")
+
+        topic = RuntimeDaemon._infer_change_topic(files)
+        paths = [f["path"].lower() for f in files]
+        has_api = any(
+            ("route" in path or "endpoint" in path or "/api/" in path or "/v1/" in path or "/v2/" in path)
+            and not RuntimeDaemon._is_test_path(path)
+            for path in paths
+        )
+        has_frontend = any(
+            (path.endswith((".tsx", ".jsx", ".vue", ".svelte", ".css", ".scss")) or path.startswith("frontend/"))
+            and not RuntimeDaemon._is_test_path(path)
+            for path in paths
+        )
+        has_service = any(
+            any(token in path for token in ("service", "worker", "manager", "queue")) and not RuntimeDaemon._is_test_path(path)
+            for path in paths
+        )
+        has_model = any(
+            any(token in path for token in ("model", "schema", "migration", "alembic")) and not RuntimeDaemon._is_test_path(path)
+            for path in paths
+        )
+        has_utility = any(
+            any(token in path for token in ("util", "helper", "middleware", "auth")) and not RuntimeDaemon._is_test_path(path)
+            for path in paths
+        )
+        has_tests = any(RuntimeDaemon._is_test_path(path) for path in paths)
+
+        areas: list[str] = []
+        if has_api:
+            areas.append("routes" if topic and "api" in topic.lower() else "API")
+        if has_frontend:
+            areas.append("UI")
+        if has_service:
+            areas.append("service flow")
+        if has_model:
+            areas.append("data model")
+        if has_utility and not has_api:
+            areas.append("helpers")
+        if node_type in ("fix", "bugfix") and has_tests and not has_frontend:
+            areas.append("tests")
+
+        unique_areas: list[str] = []
+        for area in areas:
+            if area not in unique_areas:
+                unique_areas.append(area)
+        areas = unique_areas[:2]
+
+        if topic:
+            if len(areas) >= 2:
+                return f"{verb} {topic} {areas[0]} and {areas[1]}"
+            if len(areas) == 1:
+                return f"{verb} {topic} {areas[0]}"
+            return f"{verb} {topic}"
+
+        if len(areas) >= 2:
+            return f"{verb} {areas[0]} and {areas[1]}"
+        if len(areas) == 1:
+            return f"{verb} {areas[0]}"
+
+        # Final fallback — generic but still English
+        _FALLBACK = {
+            "analysis": "analyze requirements and generate specifications",
+            "planning": "generate implementation plan and task breakdown",
+            "coding": "implement feature changes",
+            "fix": "apply bug fix",
+            "testing": "add automated test coverage",
+            "review": "generate code review documentation",
+            "refactor": "refactor code structure",
+            "documentation": "update project documentation",
+            "improvement": "apply code improvements",
+        }
+        return _FALLBACK.get(node_type, "implement changes")
+
+    @staticmethod
+    def _build_bullet_body(
+        node_type: str,
+        files: list[dict],
+        workspace_path: Path | None = None,
+    ) -> list[str]:
+        """Build a Claude Code-style bullet-point body describing specific changes.
+
+        Each bullet describes what a file or group of related files does, using
+        the actual filename and directory context to produce specific, useful
+        descriptions rather than generic counts or labels.
+
+        Example output:
+          - Add `UserAuthService` with JWT token generation and refresh logic
+          - Update `/api/v1/users` endpoints to require Bearer token authentication
+          - Add unit tests for token validation and expiry edge cases
+          - Update `alembic/versions/` migration to add `users.token_hash` column
+
+        Rules:
+          - Max 8 bullets (most important first, by additions+deletions)
+          - Related files are grouped into a single bullet (e.g. test files)
+          - File paths are shown in backticks for readability
+          - Status prefix: "Add" for new files (A), "Remove" for deleted (D),
+            "Update" for modified (M), "Refactor" for pure-deletion rewrites
+          - Never shows raw +/- counts or file sizes
+        """
+        if not files:
+            return []
+
+        # ── File classification helpers ────────────────────────────────────
+        def _is_test(path: str) -> bool:
+            return RuntimeDaemon._is_test_path(path)
+
+        def _is_doc(path: str) -> bool:
+            p = path.lower()
+            return p.endswith((".md", ".rst")) or p.startswith("docs/")
+
+        def _is_migration(path: str) -> bool:
+            p = path.lower()
+            return "alembic" in p or "migration" in p or p.endswith(".sql")
+
+        def _is_config(path: str) -> bool:
+            p = path.lower()
+            fname = p.rsplit("/", 1)[-1]
+            return fname.endswith((".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".env")) and not _is_doc(p)
+
+        def _is_frontend(path: str) -> bool:
+            p = path.lower()
+            return p.endswith((".tsx", ".jsx", ".vue", ".svelte", ".css", ".scss")) or p.startswith("frontend/")
+
+        def _status_verb(f: dict) -> str:
+            s = f.get("status", "M")
+            adds = f.get("additions", 0)
+            dels = f.get("deletions", 0)
+            if s == "A":
+                return "Add"
+            if s == "D":
+                return "Remove"
+            if adds > 0 and dels == 0:
+                return "Add"
+            if adds == 0 and dels > 0:
+                return "Remove"
+            if dels > adds * 2:
+                return "Refactor"
+            return "Update"
+
+        def _has_api(group: list[dict]) -> bool:
+            return any(
+                ("route" in f["path"].lower() or "endpoint" in f["path"].lower() or "/api/" in f["path"].lower() or "/v1/" in f["path"].lower() or "/v2/" in f["path"].lower())
+                and not _is_test(f["path"])
+                for f in group
+            )
+
+        def _has_frontend(group: list[dict]) -> bool:
+            return any(
+                (f["path"].lower().endswith((".tsx", ".jsx", ".vue", ".svelte", ".css", ".scss")) or f["path"].lower().startswith("frontend/"))
+                and not _is_test(f["path"])
+                for f in group
+            )
+
+        def _has_service(group: list[dict]) -> bool:
+            return any(
+                any(token in f["path"].lower() for token in ("service", "worker", "manager", "queue")) and not _is_test(f["path"])
+                for f in group
+            )
+
+        def _has_model(group: list[dict]) -> bool:
+            return any(
+                any(token in f["path"].lower() for token in ("model", "schema", "migration", "alembic")) and not _is_test(f["path"])
+                for f in group
+            )
+
+        def _has_utility(group: list[dict]) -> bool:
+            return any(
+                any(token in f["path"].lower() for token in ("util", "helper", "middleware", "auth")) and not _is_test(f["path"])
+                for f in group
+            )
+
+        # ── Sort files by change volume (most significant first) ───────────
+        sorted_files = sorted(
+            files,
+            key=lambda f: f.get("additions", 0) + f.get("deletions", 0),
+            reverse=True,
+        )
+
+        # ── Group special categories for combined bullets ──────────────────
+        tests = [f for f in sorted_files if _is_test(f["path"])]
+        migrations = [f for f in sorted_files if _is_migration(f["path"])]
+        docs = [f for f in sorted_files if _is_doc(f["path"]) and not _is_migration(f["path"])]
+        configs = [f for f in sorted_files if _is_config(f["path"])]
+        main_files = [
+            f for f in sorted_files
+            if not _is_test(f["path"]) and not _is_migration(f["path"])
+            and not _is_doc(f["path"]) and not _is_config(f["path"])
+        ]
+
+        bullets: list[str] = []
+
+        topic = RuntimeDaemon._infer_change_topic(files)
+        primary_surfaces: list[str] = []
+        if _has_api(main_files):
+            primary_surfaces.append("API routes")
+        if _has_frontend(main_files):
+            primary_surfaces.append("UI")
+        if _has_service(main_files):
+            primary_surfaces.append("service flow")
+        if _has_model(main_files):
+            primary_surfaces.append("data model")
+        if _has_utility(main_files) and "service flow" not in primary_surfaces:
+            primary_surfaces.append("request/auth helpers")
+
+        primary_surfaces = primary_surfaces[:2]
+        primary_verb = "Fix" if node_type in ("fix", "bugfix") else "Implement"
+        if main_files:
+            if topic and len(primary_surfaces) >= 2:
+                bullets.append(f"- {primary_verb} {topic} {primary_surfaces[0]} and {primary_surfaces[1]}")
+            elif topic and len(primary_surfaces) == 1:
+                bullets.append(f"- {primary_verb} {topic} {primary_surfaces[0]}")
+            elif len(primary_surfaces) >= 2:
+                bullets.append(f"- {primary_verb} {primary_surfaces[0]} and {primary_surfaces[1]}")
+            elif len(primary_surfaces) == 1:
+                bullets.append(f"- {primary_verb} {primary_surfaces[0]}")
+
+        if migrations:
+            if len(migrations) == 1:
+                verb = _status_verb(migrations[0])
+                mpath = migrations[0]["path"]
+                mname = mpath.rsplit("/", 1)[-1].rsplit(".", 1)[0]
+                mdesc = re.sub(r"^\d+[_\-]", "", mname).replace("_", " ").strip()
+                bullets.append(f"- {verb} `{mdesc}` database migration")
+            else:
+                bullets.append(f"- Add {len(migrations)} database migrations")
+
+        if tests:
+            test_verbs = {_status_verb(t) for t in tests}
+            tv = "Add" if "Add" in test_verbs else "Update"
+            support_topic = topic or RuntimeDaemon._infer_change_topic(tests, include_support=True)
+            if len(tests) == 1:
+                stem = tests[0]["path"].rsplit("/", 1)[-1].rsplit(".", 1)[0]
+                stem = re.sub(r"^test_|_test$", "", stem).replace("_", " ")
+                if support_topic:
+                    bullets.append(f"- {tv} test coverage for {support_topic}")
+                else:
+                    bullets.append(f"- {tv} `{stem}` test coverage" if stem else f"- {tv} unit tests")
+            else:
+                if support_topic:
+                    bullets.append(f"- {tv} regression and integration coverage for {support_topic}")
+                else:
+                    bullets.append(f"- {tv} {len(tests)} test files")
+
+        if docs:
+            if len(docs) == 1:
+                verb = _status_verb(docs[0])
+                fname = docs[0]["path"].rsplit("/", 1)[-1]
+                bullets.append(f"- {verb} `{fname}` documentation")
+            else:
+                bullets.append(f"- Update {len(docs)} documentation files")
+
+        if configs:
+            if len(configs) == 1:
+                verb = _status_verb(configs[0])
+                fname = configs[0]["path"].rsplit("/", 1)[-1]
+                bullets.append(f"- {verb} `{fname}` configuration")
+            else:
+                bullets.append(f"- Update {len(configs)} configuration files")
+
+        return bullets[:8]
+
+    @staticmethod
+    def _build_narrative_body(
+        node_type: str,
+        sections: dict,
+        sanitized_title: str = "",
+        files: list[dict] | None = None,
+    ) -> list[str]:
+        """[Legacy] Build narrative sentences — kept for callers that still use it.
+
+        Prefer _build_bullet_body for new call sites.
+        """
+        return RuntimeDaemon._build_bullet_body(node_type, files or [], None)
 
     async def _extract_analysis_insights(
         self, files: list[dict], workspace_path: Path
@@ -6009,10 +6572,10 @@ class RuntimeDaemon:
 
         lines: list[str] = []
 
-        # Summary — word-wrap at 78 chars
+        # Summary — word-wrap at 78 chars; strip non-ASCII to keep English-only
+        import re as _re2
         raw_summary = data.get("summary")
         if isinstance(raw_summary, dict):
-            # Some agents produce summary as a structured object; extract description
             summary = (
                 raw_summary.get("description")
                 or raw_summary.get("title")
@@ -6025,7 +6588,8 @@ class RuntimeDaemon:
             summary = raw_summary
         else:
             summary = str(raw_summary) if raw_summary else ""
-        summary = summary.strip()
+        summary = _re2.sub(r"[^\x00-\x7F]+", " ", summary.strip())
+        summary = _re2.sub(r"\s+", " ", summary).strip()
         if summary:
             words = summary.split()
             current = ""
@@ -6148,6 +6712,7 @@ class RuntimeDaemon:
         """
         git = self.workspace_manager._git
         target = f"origin/{default_branch}"
+        _git_name, _git_email = _resolve_git_author(task.project)
 
         # Fetch latest remote state
         try:
@@ -6195,8 +6760,8 @@ class RuntimeDaemon:
             # ── Tier 1: rebase (safe — branch not yet on remote) ──
             try:
                 await git(
-                    "-c", "user.name=Forgexa Agent",
-                    "-c", "user.email=agent@forgexa.net",
+                    "-c", f"user.name={_git_name}",
+                    "-c", f"user.email={_git_email}",
                     "rebase", target,
                     cwd=workspace_path, timeout=120,
                 )
@@ -6218,8 +6783,8 @@ class RuntimeDaemon:
         # ── Tier 2: merge ──
         try:
             await git(
-                "-c", "user.name=Forgexa Agent",
-                "-c", "user.email=agent@forgexa.net",
+                "-c", f"user.name={_git_name}",
+                "-c", f"user.email={_git_email}",
                 "merge", target, "--no-edit",
                 cwd=workspace_path, timeout=120,
             )
@@ -6242,8 +6807,7 @@ class RuntimeDaemon:
         in a clean state and push whatever we had before.
         """
         git = self.workspace_manager._git
-
-        # 1. List conflicted files
+        _git_name, _git_email = _resolve_git_author(task.project)
         try:
             diff_out = await git(
                 "diff", "--name-only", "--diff-filter=U", cwd=workspace_path,
@@ -6256,8 +6820,8 @@ class RuntimeDaemon:
             # No actual conflicts (merge completed or something unusual)
             try:
                 await git(
-                    "-c", "user.name=Forgexa Agent",
-                    "-c", "user.email=agent@forgexa.net",
+                    "-c", f"user.name={_git_name}",
+                    "-c", f"user.email={_git_email}",
                     "merge", "--continue", cwd=workspace_path,
                 )
             except RuntimeError:
@@ -6382,8 +6946,8 @@ class RuntimeDaemon:
             await git("add", "-A", cwd=workspace_path)
             try:
                 await git(
-                    "-c", "user.name=Forgexa Agent",
-                    "-c", "user.email=agent@forgexa.net",
+                    "-c", f"user.name={_git_name}",
+                    "-c", f"user.email={_git_email}",
                     "commit", "--no-edit",
                     cwd=workspace_path,
                 )
@@ -6399,9 +6963,13 @@ class RuntimeDaemon:
             except RuntimeError:
                 await git("reset", "--hard", "HEAD", cwd=workspace_path)
 
-    async def _push_branch(self, workspace_path: Path, project_key: str = "default") -> str | None:
+    async def _push_branch(
+        self, workspace_path: Path, project_key: str = "default",
+        task: "TaskInfo | None" = None,
+    ) -> str | None:
         """Push the current branch to origin. Returns error message on failure, None on success."""
         git = self.workspace_manager._git
+        _git_name, _git_email = _resolve_git_author(task.project if task else {})
         try:
             # Get current branch name
             branch = (await git("rev-parse", "--abbrev-ref", "HEAD", cwd=workspace_path)).strip()
@@ -6538,8 +7106,8 @@ class RuntimeDaemon:
                                             cwd=workspace_path,
                                         )
                                         await git(
-                                            "-c", "user.name=Forgexa Agent",
-                                            "-c", "user.email=agent@forgexa.net",
+                                            "-c", f"user.name={_git_name}",
+                                            "-c", f"user.email={_git_email}",
                                             "cherry-pick", *new_shas,
                                             cwd=workspace_path,
                                         )
@@ -6587,8 +7155,8 @@ class RuntimeDaemon:
                                 #    version.  This is correct: on an agent-managed feature
                                 #    branch the latest agent output is always authoritative.
                                 await git(
-                                    "-c", "user.name=Forgexa Agent",
-                                    "-c", "user.email=agent@forgexa.net",
+                                    "-c", f"user.name={_git_name}",
+                                    "-c", f"user.email={_git_email}",
                                     "rebase", "-X", "theirs", f"origin/{branch}",
                                     cwd=workspace_path,
                                 )

{forgexa_cli-1.10.2 → forgexa_cli-1.10.4}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.10.2
+Version: 1.10.4
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.10.2 → forgexa_cli-1.10.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.10.2"
+version = "1.10.4"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = { text = "MIT" }