project-agent 0.2.1__tar.gz → 0.2.2__tar.gz

{project_agent-0.2.1 → project_agent-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: project-agent
-Version: 0.2.1
+Version: 0.2.2
 Summary: Project Agent Python CLI core
 Requires-Python: >=3.11
 Requires-Dist: typer<1,>=0.12

{project_agent-0.2.1 → project_agent-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "project-agent"
-version = "0.2.1"
+version = "0.2.2"
 description = "Project Agent Python CLI core"
 requires-python = ">=3.11"
 dependencies = [

project_agent-0.2.2/src/project_agent/application/context/project_summary.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from datetime import UTC, date, datetime
+from typing import Any, Protocol
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from project_agent.domain.project_context.models import (
+    PersonalTaskSummary,
+    ProjectSummaryResult,
+    TeamTaskSummary,
+)
+from project_agent.domain.shared.statuses import (
+    is_done_status,
+    is_terminal_task_status,
+    normalize_task_status,
+)
+
+
+class ProjectStore(Protocol):
+    def find_by_id(self, project_id: str) -> Any: ...
+
+
+class TaskStore(Protocol):
+    def list_by_project_id(self, project_id: str, task_id: str | None = None) -> list[Any]: ...
+
+
+def build_project_summary(
+    *,
+    project_id: str,
+    user_id: str,
+    timezone: str | None,
+    project_store: ProjectStore,
+    task_store: TaskStore,
+) -> ProjectSummaryResult | None:
+    project = project_store.find_by_id(project_id)
+    if not project:
+        return None
+
+    tz = resolve_summary_timezone(timezone or project.get("timezone") or "UTC")
+    today = datetime.now(tz).date()
+    tasks = task_store.list_by_project_id(project_id)
+
+    return ProjectSummaryResult(
+        project_id=project["project_id"],
+        project_name=project["project_name"],
+        team_task=_build_team_task_summary(tasks, today=today, tz=tz),
+        personal=_build_personal_task_summary(tasks, user_id=user_id, today=today, tz=tz),
+        updated_at=project.get("last_updated_at"),
+    )
+
+
+def resolve_summary_timezone(value: str) -> ZoneInfo:
+    try:
+        return ZoneInfo(value)
+    except ZoneInfoNotFoundError as exc:
+        raise ValueError(f"unknown timezone: {value}") from exc
+
+
+def _build_team_task_summary(
+    tasks: list[Any],
+    *,
+    today: date,
+    tz: ZoneInfo,
+) -> TeamTaskSummary:
+    return TeamTaskSummary(
+        status="HAS_TASK" if tasks else "NO_TASK",
+        new_assigned_today=sum(1 for task in tasks if _is_today(_task_value(task, "created_at"), today, tz)),
+        completed_today=sum(
+            1
+            for task in tasks
+            if is_done_status(_task_value(task, "task_status"))
+            and _is_today(_task_value(task, "updated_at") or _task_value(task, "last_updated_at"), today, tz)
+        ),
+        in_progress=sum(
+            1
+            for task in tasks
+            if normalize_task_status(_task_value(task, "task_status")) == "in_progress"
+        ),
+    )
+
+
+def _build_personal_task_summary(
+    tasks: list[Any],
+    *,
+    user_id: str,
+    today: date,
+    tz: ZoneInfo,
+) -> PersonalTaskSummary:
+    personal_tasks = [task for task in tasks if _task_value(task, "owner_user_id") == user_id]
+    return PersonalTaskSummary(
+        new_tasks_today=sum(
+            1 for task in personal_tasks if _is_today(_task_value(task, "created_at"), today, tz)
+        ),
+        due_tasks_today=sum(
+            1
+            for task in personal_tasks
+            if _task_due_date(_task_value(task, "end_date"), tz=tz) == today
+            and not is_terminal_task_status(_task_value(task, "task_status"))
+        ),
+    )
+
+
+def _task_value(task: Any, key: str) -> Any:
+    if isinstance(task, dict):
+        return task.get(key)
+    return getattr(task, key, None)
+
+
+def _is_today(value: Any, today: date, tz: ZoneInfo) -> bool:
+    parsed = _parse_datetime(value, tz=tz)
+    return parsed is not None and parsed.date() == today
+
+
+def _task_due_date(value: Any, *, tz: ZoneInfo) -> date | None:
+    if value is None:
+        return None
+    if isinstance(value, date) and not isinstance(value, datetime):
+        return value
+    token = str(value).strip()
+    if not token:
+        return None
+    try:
+        return date.fromisoformat(token[:10])
+    except ValueError:
+        parsed = _parse_datetime(token, tz=tz)
+        return parsed.date() if parsed is not None else None
+
+
+def _parse_datetime(value: Any, *, tz: ZoneInfo) -> datetime | None:
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        parsed = value
+    else:
+        token = str(value).strip()
+        if not token:
+            return None
+        try:
+            parsed = datetime.fromisoformat(token.replace("Z", "+00:00"))
+        except ValueError:
+            return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed.astimezone(tz)

{project_agent-0.2.1 → project_agent-0.2.2}/src/project_agent/domain/project_context/models.py

@@ -137,6 +137,32 @@ class GetTaskResult(ProjectAgentModel):
     task: TaskSummary = Field(description="命中的单条 Task 详情。")
 
 
+class TeamTaskSummary(ProjectAgentModel):
+    """项目团队任务汇总。"""
+
+    status: str = Field(description="团队任务状态，例如 HAS_TASK 或 NO_TASK。")
+    new_assigned_today: int = Field(description="今天新分配到项目的任务数量。")
+    completed_today: int = Field(description="今天完成的项目任务数量。")
+    in_progress: int = Field(description="进行中的项目任务数量。")
+
+
+class PersonalTaskSummary(ProjectAgentModel):
+    """当前用户在项目内的任务汇总。"""
+
+    new_tasks_today: int = Field(description="今天分配给当前用户的新任务数量。")
+    due_tasks_today: int = Field(description="今天到期且未终态的当前用户任务数量。")
+
+
+class ProjectSummaryResult(ProjectAgentModel):
+    """`context project-summary` 的结构化输出。"""
+
+    project_id: str = Field(description="项目内部唯一标识。")
+    project_name: str = Field(description="项目名称。")
+    team_task: TeamTaskSummary = Field(description="团队任务汇总。")
+    personal: PersonalTaskSummary = Field(description="当前用户任务汇总。")
+    updated_at: str | None = Field(default=None, description="项目 UTC 更新时间。")
+
+
 class PendingStateSummary(ProjectAgentModel):
     """项目上下文里暴露给 router 或 gate 的 pending state 摘要。"""
 

{project_agent-0.2.1 → project_agent-0.2.2}/src/project_agent/infrastructure/db/repositories.py

@@ -1914,6 +1914,8 @@ def _to_participant_row(record: ProjectParticipantRecord) -> dict:
         "user_id": record.user_id,
         "role": record.role,
         "status": record.status,
+        "created_at": _dump_datetime(record.created_at),
+        "updated_at": _dump_datetime(record.updated_at),
     }
 
 
@@ -1978,6 +1980,8 @@ def _to_task_row(record: ProjectTaskRecord) -> dict:
         "start_date": record.start_date,
         "end_date": record.end_date,
         "last_updated_at": _dump_datetime(record.last_updated_at),
+        "created_at": _dump_datetime(record.created_at),
+        "updated_at": _dump_datetime(record.updated_at),
         "latest_update": payload.get("latest_update"),
         "has_effective_update": payload.get("has_effective_update"),
         "effective_update_fields": payload.get("effective_update_fields", []),

{project_agent-0.2.1 → project_agent-0.2.2}/src/project_agent/interface/cli/commands/context.py

@@ -10,6 +10,7 @@ from project_agent.application.context.get_task import get_task as get_task_serv
 from project_agent.application.context.get_user_context import get_user_context as get_user_context_service
 from project_agent.application.context.list_tasks import list_tasks as list_tasks_service
 from project_agent.application.context.list_projects import list_projects as list_projects_service
+from project_agent.application.context.project_summary import build_project_summary as build_project_summary_service
 from project_agent.application.context.resolve_group import resolve_group as resolve_group_service
 from project_agent.application.context.resolve_user import resolve_user as resolve_user_service
 from project_agent.application.context.search_user import search_user as search_user_service
@@ -101,6 +102,14 @@ class ListTasksCommandInput(BaseModel):
     external_subject_id: str | None = None
 
 
+class ProjectSummaryCommandInput(BaseModel):
+    project_id: str
+    user_id: str | None = None
+    channel: str | None = None
+    external_subject_id: str | None = None
+    timezone: str | None = None
+
+
 class ResolveUserCommandInput(BaseModel):
     channel: str
     external_subject_id: str
@@ -378,6 +387,68 @@ def list_projects(
     typer.echo(json.dumps(result, indent=2, ensure_ascii=True))
 
 
+@app.command("project-summary", help="读取项目团队与当前用户的任务汇总。")
+def project_summary(
+    project_id: str = project_id_option(),
+    user_id: str | None = typer.Option(None, "--user-id", help="内部 canonical userId。"),
+    channel: str | None = channel_option(),
+    external_subject_id: str | None = typer.Option(None, "--external-subject-id", help="渠道侧主体 ID。与 --channel 配合后可直接解析内部 userId。"),
+    timezone: str | None = typer.Option(None, "--timezone", help="用于计算今日统计的 IANA 时区，例如 Asia/Shanghai。"),
+    db_path: str | None = db_path_option(),
+) -> None:
+    payload = ProjectSummaryCommandInput(
+        project_id=project_id,
+        user_id=user_id,
+        channel=channel,
+        external_subject_id=external_subject_id,
+        timezone=timezone,
+    )
+    _validate_external_identity_args(
+        channel=payload.channel,
+        external_subject_id=payload.external_subject_id,
+    )
+    if payload.user_id is not None and payload.external_subject_id is not None:
+        _echo_invalid_input("user_id cannot be used together with channel/external_subject_id")
+        raise typer.Exit(code=1)
+    if payload.user_id is None and payload.external_subject_id is None:
+        _echo_invalid_input("project-summary requires --user-id or --channel with --external-subject-id")
+        raise typer.Exit(code=1)
+
+    with open_session(db_path) as session:
+        resolved_user_id = payload.user_id
+        if payload.external_subject_id is not None:
+            resolved_user_id = _resolve_user_id_or_exit(
+                session=session,
+                channel=payload.channel,
+                external_subject_id=payload.external_subject_id,
+            )
+        if resolved_user_id is None:
+            _echo_invalid_input("project-summary requires a resolved user_id")
+            raise typer.Exit(code=1)
+        try:
+            result = build_project_summary_service(
+                project_id=payload.project_id,
+                user_id=resolved_user_id,
+                timezone=payload.timezone,
+                project_store=SqlAlchemyProjectStore(session),
+                task_store=SqlAlchemyTaskStore(session),
+            )
+        except ValueError as exc:
+            _echo_invalid_input(str(exc))
+            raise typer.Exit(code=1) from exc
+
+    if result is None:
+        typer.echo(
+            '{\n'
+            '  "status": "not_found",\n'
+            f'  "projectId": "{payload.project_id}"\n'
+            '}'
+        )
+        raise typer.Exit(code=1)
+
+    typer.echo(result.model_dump_json(indent=2, by_alias=True))
+
+
 @app.command("get-project-owner", help="按项目 ID 查询项目 Owner 用户详情及渠道身份映射。")
 def get_project_owner(
     project_id: str = project_id_option(),

{project_agent-0.2.1 → project_agent-0.2.2}/src/project_agent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: project-agent
-Version: 0.2.1
+Version: 0.2.2
 Summary: Project Agent Python CLI core
 Requires-Python: >=3.11
 Requires-Dist: typer<1,>=0.12

{project_agent-0.2.1 → project_agent-0.2.2}/src/project_agent.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ src/project_agent/application/context/get_task.py
 src/project_agent/application/context/get_user_context.py
 src/project_agent/application/context/list_projects.py
 src/project_agent/application/context/list_tasks.py
+src/project_agent/application/context/project_summary.py
 src/project_agent/application/context/resolve_binding.py
 src/project_agent/application/context/resolve_group.py
 src/project_agent/application/context/resolve_user.py
@@ -125,6 +126,7 @@ tests/test_context_get_project_owner.py
 tests/test_context_get_project_pending_states.py
 tests/test_context_list_projects.py
 tests/test_context_list_tasks.py
+tests/test_context_project_summary.py
 tests/test_context_resolve_binding.py
 tests/test_context_search_user.py
 tests/test_context_upsert_user_identity.py

project_agent-0.2.2/tests/test_context_project_summary.py

@@ -0,0 +1,322 @@
+import json
+import sqlite3
+import sys
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[4]))
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from typer.testing import CliRunner
+
+from project_agent.infrastructure.db.schema import create_schema
+from project_agent.interface.cli.app import app
+from runtime.mushroomAgent.deploy.project_agent_api import create_router
+
+
+runner = CliRunner()
+
+
+def test_project_summary_cli_resolves_external_subject_and_returns_counts(tmp_path) -> None:
+    db_path = tmp_path / "project-agent.db"
+    create_schema(str(db_path))
+    now = datetime.now(UTC).replace(tzinfo=None)
+    _insert_user(db_path, user_id="usr_member_001", display_name="Member One")
+    _insert_identity(
+        db_path,
+        identity_id="uci_member_001",
+        user_id="usr_member_001",
+        channel="openim",
+        external_subject_id="open_user_001",
+    )
+    _insert_project(db_path, project_id="proj_summary_001", updated_at=now)
+    _insert_task(
+        db_path,
+        task_id="task_owned_due",
+        project_id="proj_summary_001",
+        owner_user_id="usr_member_001",
+        task_status="in_progress",
+        end_date=now.date().isoformat(),
+        created_at=now,
+        updated_at=now,
+    )
+    _insert_task(
+        db_path,
+        task_id="task_done_today",
+        project_id="proj_summary_001",
+        owner_user_id="usr_other_001",
+        task_status="done",
+        end_date=now.date().isoformat(),
+        created_at=now - timedelta(days=1),
+        updated_at=now,
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "context",
+            "project-summary",
+            "--project-id",
+            "proj_summary_001",
+            "--channel",
+            "openim",
+            "--external-subject-id",
+            "open_user_001",
+            "--timezone",
+            "UTC",
+            "--db-path",
+            str(db_path),
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["projectId"] == "proj_summary_001"
+    assert payload["projectName"] == "Summary Project"
+    assert payload["teamTask"] == {
+        "status": "HAS_TASK",
+        "newAssignedToday": 1,
+        "completedToday": 1,
+        "inProgress": 1,
+    }
+    assert payload["personal"] == {
+        "newTasksToday": 1,
+        "dueTasksToday": 1,
+    }
+    assert payload["updatedAt"].endswith("Z")
+
+
+def test_project_summary_api_uses_backend_summary_service(tmp_path) -> None:
+    db_path = tmp_path / "project-agent.db"
+    create_schema(str(db_path))
+    now = datetime.now(UTC).replace(tzinfo=None)
+    _insert_user(db_path, user_id="usr_member_001", display_name="Member One")
+    _insert_identity(
+        db_path,
+        identity_id="uci_member_001",
+        user_id="usr_member_001",
+        channel="openim",
+        external_subject_id="open_user_001",
+    )
+    _insert_project(db_path, project_id="proj_summary_001", updated_at=now)
+    _insert_binding(
+        db_path,
+        binding_id="bind_summary_001",
+        project_id="proj_summary_001",
+        channel="openim",
+        external_channel_id="group_summary_001",
+    )
+    _insert_task(
+        db_path,
+        task_id="task_owned_due",
+        project_id="proj_summary_001",
+        owner_user_id="usr_member_001",
+        task_status="in_progress",
+        end_date=now.date().isoformat(),
+        created_at=now,
+        updated_at=now,
+    )
+
+    fastapi_app = FastAPI()
+    fastapi_app.include_router(create_router(None, {"db_path": str(db_path)}))
+    response = TestClient(fastapi_app).get(
+        "/api/projects/summary",
+        params={
+            "groupId": "group_summary_001",
+            "userId": "open_user_001",
+            "channel": "openim",
+            "timezone": "UTC",
+        },
+    )
+
+    assert response.status_code == 200
+    assert response.json()["personal"] == {
+        "newTasksToday": 1,
+        "dueTasksToday": 1,
+    }
+
+
+def test_project_summary_cli_rejects_missing_user_identity(tmp_path) -> None:
+    db_path = tmp_path / "project-agent.db"
+    create_schema(str(db_path))
+    _insert_project(db_path, project_id="proj_summary_001", updated_at=datetime.now(UTC).replace(tzinfo=None))
+
+    result = runner.invoke(
+        app,
+        [
+            "context",
+            "project-summary",
+            "--project-id",
+            "proj_summary_001",
+            "--timezone",
+            "UTC",
+            "--db-path",
+            str(db_path),
+        ],
+    )
+
+    assert result.exit_code == 1
+    assert json.loads(result.stdout)["message"] == (
+        "project-summary requires --user-id or --channel with --external-subject-id"
+    )
+
+
+def _insert_project(db_path, *, project_id: str, updated_at: datetime) -> None:
+    with sqlite3.connect(db_path) as connection:
+        connection.execute(
+            """
+            INSERT INTO projects (
+              project_id,
+              project_name,
+              owner_user_id,
+              primary_goal,
+              mind_stage,
+              lifecycle_status,
+              current_revision_id,
+              current_version_id,
+              timezone,
+              created_at,
+              updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                project_id,
+                "Summary Project",
+                "usr_owner",
+                "Summarize project tasks",
+                "v1",
+                "active",
+                "rev_summary_001",
+                "ver_summary_001",
+                "UTC",
+                _db_datetime(updated_at),
+                _db_datetime(updated_at),
+            ),
+        )
+        connection.commit()
+
+
+def _insert_user(db_path, *, user_id: str, display_name: str) -> None:
+    with sqlite3.connect(db_path) as connection:
+        connection.execute(
+            """
+            INSERT INTO users (
+              user_id,
+              display_name,
+              status,
+              created_at,
+              updated_at
+            ) VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+            """,
+            (user_id, display_name, "active"),
+        )
+        connection.commit()
+
+
+def _insert_identity(
+    db_path,
+    *,
+    identity_id: str,
+    user_id: str,
+    channel: str,
+    external_subject_id: str,
+) -> None:
+    with sqlite3.connect(db_path) as connection:
+        connection.execute(
+            """
+            INSERT INTO user_channel_identities (
+              identity_id,
+              user_id,
+              channel,
+              external_subject_id,
+              status,
+              profile_json,
+              created_at,
+              updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+            """,
+            (identity_id, user_id, channel, external_subject_id, "active", "{}"),
+        )
+        connection.commit()
+
+
+def _insert_binding(
+    db_path,
+    *,
+    binding_id: str,
+    project_id: str,
+    channel: str,
+    external_channel_id: str,
+) -> None:
+    with sqlite3.connect(db_path) as connection:
+        connection.execute(
+            """
+            INSERT INTO project_bindings (
+              binding_id,
+              project_id,
+              channel,
+              external_channel_id,
+              binding_kind,
+              status,
+              payload_json,
+              created_at,
+              updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+            """,
+            (binding_id, project_id, channel, external_channel_id, "project_group", "active", "{}"),
+        )
+        connection.commit()
+
+
+def _insert_task(
+    db_path,
+    *,
+    task_id: str,
+    project_id: str,
+    owner_user_id: str,
+    task_status: str,
+    end_date: str,
+    created_at: datetime,
+    updated_at: datetime,
+) -> None:
+    with sqlite3.connect(db_path) as connection:
+        connection.execute(
+            """
+            INSERT INTO project_tasks (
+              task_id,
+              project_id,
+              version_id,
+              task_name,
+              task_description,
+              owner_user_id,
+              task_status,
+              start_date,
+              end_date,
+              last_updated_at,
+              payload_json,
+              created_at,
+              updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                task_id,
+                project_id,
+                "ver_summary_001",
+                task_id,
+                f"{task_id} description",
+                owner_user_id,
+                task_status,
+                created_at.date().isoformat(),
+                end_date,
+                _db_datetime(updated_at),
+                "{}",
+                _db_datetime(created_at),
+                _db_datetime(updated_at),
+            ),
+        )
+        connection.commit()
+
+
+def _db_datetime(value: datetime) -> str:
+    return value.isoformat(sep=" ")