Week Report System

{
  "skill_name": "week-report-system",
  "evals": [
    {
      "id": 1,
      "name": "environment-setup",
      "prompt": "我想使用周报系统，写一份上周的工作总结",
      "expected_output": "应该检测到环境变量缺失，并引导用户进行GitHub仓库和Token的配置",
      "files": [],
      "assertions": [
        {
          "name": "checks-env-vars",
          "description": "检查是否正确识别环境变量缺失",
          "expected": "Should detect missing WEEK_REPORT_GIT_USERNAME, WEEK_REPORT_GIT_PERSONAL_TOKEN, or WEEK_REPORT_GIT_REPO and guide user to setup"
        }
      ]
    },
    {
      "id": 2,
      "name": "conversation-material-capture",
      "prompt": "帮我写一个Python函数，实现斐波那契数列，(测试对话记录功能，环境变量已配置好)",
      "expected_output": "生成斐波那契函数后，应该以 conversation material 的方式在后台记录这次对话",
      "files": [],
      "assertions": [
        {
          "name": "generates-code",
          "description": "生成了有效的Python代码",
          "expected": "Should output a working Python function for Fibonacci sequence"
        },
        {
          "name": "captures-conversation-material",
          "description": "按 conversation material 的语义进行后台记录",
          "expected": "Should capture the exchange as a conversation material with summary/outcome fields"
        }
      ]
    },
    {
      "id": 3,
      "name": "document-material-ingestion",
      "prompt": "把这份 experiment 方案总结成周报素材，项目是 rayneo_hotword_tflm",
      "expected_output": "应该识别为 document 类型的周报素材，并提炼出标题、摘要、结果与下一步",
      "files": [],
      "assertions": [
        {
          "name": "uses-document-material-shape",
          "description": "使用文档素材结构",
          "expected": "Should capture document material with project, title, summary, outcome, and next_actions"
        }
      ]
    },
    {
      "id": 4,
      "name": "weekly-report-generation",
      "prompt": "总结2024年第51周的工作",
      "expected_output": "优先从结构化 materials 读取该周素材，必要时回退到 legacy 对话摘要，并生成结构化周报",
      "files": [],
      "assertions": [
        {
          "name": "generates-structured-report",
          "description": "生成结构化的周报",
          "expected": "Should generate a report with: overview, project sections, highlights, and summary"
        },
        {
          "name": "total-part-total-structure",
          "description": "遵循总分总结构",
          "expected": "Report should follow Total-Part-Total structure (overview at beginning, detailed sections in middle, summary at end)"
        },
        {
          "name": "prioritizes-materials",
          "description": "优先使用结构化素材",
          "expected": "Should prioritize structured materials and use legacy conversation digests only as fallback"
        }
      ]
    }
  ]
}

#!/usr/bin/env python3
"""
Conversation and material logger for the Week Report System.

This module stores structured weekly-report materials in JSONL form and keeps a
human-readable digest for quick inspection and backward compatibility.
"""

import argparse
import json
import logging
import os
import re
import uuid
from dataclasses import asdict, dataclass, field
from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List, Optional

try:
    from git_operations import create_git_manager
except ImportError:  # pragma: no cover - script/package dual use
    from .git_operations import create_git_manager


logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)


class SessionManager:
    """Manage a coarse-grained session id shared across one active chat session."""

    SESSION_FILE = "/tmp/week_report_session.txt"
    SESSION_DATE_FILE = "/tmp/week_report_session_date.txt"
    SESSION_TTL_SECONDS = 86400

    @classmethod
    def _read_recent_value(cls, path: str) -> Optional[str]:
        if not os.path.exists(path):
            return None

        try:
            file_time = os.path.getmtime(path)
            if (datetime.now().timestamp() - file_time) >= cls.SESSION_TTL_SECONDS:
                return None

            with open(path, 'r', encoding='utf-8') as handle:
                value = handle.read().strip()
            return value or None
        except Exception as exc:  # pragma: no cover - defensive
            logger.warning("Failed to read session file %s: %s", path, exc)
            return None

    @classmethod
    def _write_value(cls, path: str, value: str) -> None:
        try:
            with open(path, 'w', encoding='utf-8') as handle:
                handle.write(value)
        except Exception as exc:  # pragma: no cover - defensive
            logger.warning("Failed to write session file %s: %s", path, exc)

    @classmethod
    def get_or_create_guid(cls) -> str:
        guid = cls._read_recent_value(cls.SESSION_FILE)
        if guid:
            return guid

        guid = uuid.uuid4().hex[:8]
        cls._write_value(cls.SESSION_FILE, guid)
        return guid

    @classmethod
    def get_or_create_start_date(cls, reference_dt: Optional[datetime] = None) -> str:
        current_date = (reference_dt or datetime.now()).strftime("%Y%m%d")
        start_date = cls._read_recent_value(cls.SESSION_DATE_FILE)
        if start_date == current_date:
            return start_date

        # Split files by calendar day even if the same session crosses midnight.
        cls._write_value(cls.SESSION_DATE_FILE, current_date)
        return current_date

    @classmethod
    def reset(cls) -> None:
        for path in [cls.SESSION_FILE, cls.SESSION_DATE_FILE]:
            if os.path.exists(path):
                os.remove(path)


class PrivacyFilter:
    """Skip only for strong-sensitive phrases to reduce false positives."""

    SKIP_PHRASES = [
        'password',
        'private key',
        'api key',
        'personal access token',
        'credential',
        "don't record",
        'off record',
        'off the record',
        '不要记录',
        '跳过记录',
        '私密',
    ]

    @classmethod
    def should_skip(cls, texts: List[str]) -> bool:
        combined = "\n".join(text for text in texts if text).lower()
        return any(phrase in combined for phrase in cls.SKIP_PHRASES)


class MessageCompressor:
    """Compress long user-provided content into a reusable material summary."""

    MAX_LENGTH = 500

    @classmethod
    def compress(cls, message: str) -> str:
        if len(message) <= cls.MAX_LENGTH:
            return message.strip()

        # Keep lines with obvious requests, outcomes, or constraints.
        lines = [line.strip() for line in message.splitlines() if line.strip()]
        indicators = [
            '需要', '要求', '请', '帮我', '如何', '怎么', '总结', '纳入', 'repo',
            'plan', 'experiment', 'debug', 'issue', 'pr', 'commit',
            'need', 'please', 'help', 'how', 'why', 'summary'
        ]

        selected: List[str] = []
        for line in lines:
            lowered = line.lower()
            if any(indicator in lowered for indicator in indicators):
                selected.append(line)
            if len(" ".join(selected)) >= cls.MAX_LENGTH:
                break

        compressed = " ".join(selected) if selected else " ".join(lines[:5])
        compressed = re.sub(r'\s+', ' ', compressed).strip()

        if len(compressed) > cls.MAX_LENGTH:
            compressed = compressed[:cls.MAX_LENGTH - 3] + "..."

        return compressed or message[:cls.MAX_LENGTH - 3] + "..."


class ResponseSummarizer:
    """Condense an assistant response into a short outcome statement."""

    MAX_CHARS = 300

    @classmethod
    def summarize(cls, response: str) -> str:
        text = re.sub(r'```.*?```', ' ', response, flags=re.S)
        text = re.sub(r'\s+', ' ', text).strip()
        if not text:
            return "AI provided assistance."

        # Split conservatively and keep the first few meaningful fragments.
        fragments = [frag.strip() for frag in re.split(r'[。！？!?]\s*', text) if frag.strip()]
        summary = "。".join(fragments[:3]).strip()
        if not summary:
            summary = text
        if len(summary) > cls.MAX_CHARS:
            summary = summary[:cls.MAX_CHARS - 3] + "..."
        return summary


@dataclass
class MaterialEvent:
    timestamp: str
    source_type: str
    title: str
    summary: str
    project: str = ""
    evidence: List[str] = field(default_factory=list)
    tags: List[str] = field(default_factory=list)
    outcome: str = ""
    next_actions: List[str] = field(default_factory=list)
    content: str = ""
    metadata: Dict[str, Any] = field(default_factory=dict)

    def to_json_line(self) -> str:
        return json.dumps(asdict(self), ensure_ascii=False) + "\n"

    @property
    def dt(self) -> datetime:
        return datetime.fromisoformat(self.timestamp)


class SyncStatusTracker:
    """Persist local sync status for observability."""

    ROOT = Path.home() / ".week-report-repo"
    STATUS_FILE = ROOT / "last_sync_status.json"
    QUEUE_FILE = ROOT / "local_queue.jsonl"

    @classmethod
    def _ensure_root(cls) -> None:
        cls.ROOT.mkdir(parents=True, exist_ok=True)

    @classmethod
    def update_success(cls, payload: Dict[str, Any]) -> None:
        cls._ensure_root()
        status = {
            "status": "success",
            "updated_at": datetime.now().isoformat(timespec='seconds'),
            **payload,
        }
        cls.STATUS_FILE.write_text(json.dumps(status, ensure_ascii=False, indent=2) + "\n", encoding='utf-8')

    @classmethod
    def update_failure(cls, payload: Dict[str, Any]) -> None:
        cls._ensure_root()
        status = {
            "status": "failed",
            "updated_at": datetime.now().isoformat(timespec='seconds'),
            **payload,
        }
        cls.STATUS_FILE.write_text(json.dumps(status, ensure_ascii=False, indent=2) + "\n", encoding='utf-8')
        with cls.QUEUE_FILE.open('a', encoding='utf-8') as handle:
            handle.write(json.dumps(status, ensure_ascii=False) + "\n")


class MaterialFormatter:
    """Derive repo-relative paths and digest content."""

    @staticmethod
    def get_week_path(ts: datetime) -> str:
        week = ts.isocalendar()
        return f"{week[0]}/week{week[1]:02d}"

    @staticmethod
    def material_path(ts: datetime, start_date: str, guid: str) -> str:
        week_path = MaterialFormatter.get_week_path(ts)
        return f"{week_path}/materials/{start_date}-{guid}.jsonl"

    @staticmethod
    def digest_path(ts: datetime, start_date: str, guid: str) -> str:
        week_path = MaterialFormatter.get_week_path(ts)
        return f"{week_path}/{start_date}-{guid}.txt"

    @staticmethod
    def format_digest_header(guid: str, ts: datetime) -> str:
        week = ts.isocalendar()
        return (
            f"# Material Log: {guid}\n"
            f"# Date: {ts.strftime('%Y-%m-%d %H:%M:%S')}\n"
            f"# Week: {week[0]}-W{week[1]:02d}\n\n"
        )

    @staticmethod
    def format_digest_entry(event: MaterialEvent) -> str:
        ts = event.dt.strftime("%H:%M:%S")
        project = event.project or "-"
        tags = ", ".join(event.tags) if event.tags else "-"
        evidence = ", ".join(event.evidence) if event.evidence else "-"
        next_actions = "; ".join(event.next_actions) if event.next_actions else "-"

        return (
            f"## [{ts}] {event.source_type} | {project}\n"
            f"Title: {event.title}\n"
            f"Summary: {event.summary}\n"
            f"Outcome: {event.outcome or '-'}\n"
            f"Evidence: {evidence}\n"
            f"Tags: {tags}\n"
            f"Next: {next_actions}\n\n"
        )


class WeekReportRecorder:
    """Capture structured materials and sync them to the Git-backed repository."""

    def __init__(self, git_manager):
        self.git = git_manager

    def record_event(
        self,
        event: MaterialEvent,
        *,
        session_guid: Optional[str] = None,
        session_start_date: Optional[str] = None,
        max_retries: int = 3,
    ) -> bool:
        if PrivacyFilter.should_skip([event.title, event.summary, event.outcome, event.content]):
            logger.info("Skipping material capture for privacy")
            SyncStatusTracker.update_success({
                "reason": "skipped_privacy",
                "source_type": event.source_type,
                "title": event.title,
            })
            return True

        guid = session_guid or SessionManager.get_or_create_guid()
        start_date = session_start_date or SessionManager.get_or_create_start_date(event.dt)
        material_path = MaterialFormatter.material_path(event.dt, start_date, guid)
        digest_path = MaterialFormatter.digest_path(event.dt, start_date, guid)
        week_path = MaterialFormatter.get_week_path(event.dt)

        try:
            self.git.pull()

            digest_full_path = os.path.join(self.git.repo_path, digest_path)
            if not os.path.exists(digest_full_path):
                self.git.append_to_file(digest_path, MaterialFormatter.format_digest_header(guid, event.dt))

            self.git.append_to_file(material_path, event.to_json_line())
            self.git.append_to_file(digest_path, MaterialFormatter.format_digest_entry(event))

            commit_message = f"Capture {event.source_type} {guid} [{week_path}]"
            success = self.git.commit_and_push(commit_message, max_retries=max_retries)

            payload = {
                "source_type": event.source_type,
                "project": event.project,
                "title": event.title,
                "guid": guid,
                "week_path": week_path,
                "material_path": material_path,
                "digest_path": digest_path,
            }
            if success:
                SyncStatusTracker.update_success(payload)
                logger.info("Captured material: %s", material_path)
            else:
                SyncStatusTracker.update_failure({**payload, "error": "commit_or_push_failed"})
                logger.warning("Failed to sync material after retries: %s", material_path)
            return success
        except Exception as exc:  # pragma: no cover - defensive
            payload = {
                "source_type": event.source_type,
                "project": event.project,
                "title": event.title,
                "guid": guid,
                "week_path": week_path,
                "material_path": material_path,
                "digest_path": digest_path,
                "error": str(exc),
                "event": asdict(event),
            }
            SyncStatusTracker.update_failure(payload)
            logger.error("Error capturing material: %s", exc)
            return False

    def record_conversation(
        self,
        user_message: str,
        assistant_response: str,
        *,
        project: str = "",
        tags: Optional[List[str]] = None,
        evidence: Optional[List[str]] = None,
        next_actions: Optional[List[str]] = None,
    ) -> bool:
        event = MaterialEvent(
            timestamp=datetime.now().isoformat(timespec='seconds'),
            source_type="conversation",
            title="Work conversation",
            summary=MessageCompressor.compress(user_message),
            project=project,
            evidence=evidence or [],
            tags=['conversation', *(tags or [])],
            outcome=ResponseSummarizer.summarize(assistant_response),
            next_actions=next_actions or [],
            content=MessageCompressor.compress(user_message),
            metadata={"session_guid": SessionManager.get_or_create_guid()},
        )
        return self.record_event(event)

    def load_week_materials(self, year: int, week: int) -> List[Dict[str, Any]]:
        """Read structured materials for a week from the local repo clone."""
        week_root = Path(self.git.repo_path) / f"{year}/week{week:02d}/materials"
        if not week_root.exists():
            return []

        items: List[Dict[str, Any]] = []
        for path in sorted(week_root.glob("*.jsonl")):
            with path.open('r', encoding='utf-8') as handle:
                for line in handle:
                    line = line.strip()
                    if not line:
                        continue
                    try:
                        items.append(json.loads(line))
                    except json.JSONDecodeError:
                        logger.warning("Skipping malformed JSONL line in %s", path)
        items.sort(key=lambda item: item.get("timestamp", ""))
        return items


def build_material_event(
    source_type: str,
    title: str,
    summary: str,
    *,
    project: str = "",
    tags: Optional[List[str]] = None,
    evidence: Optional[List[str]] = None,
    outcome: str = "",
    next_actions: Optional[List[str]] = None,
    content: str = "",
    metadata: Optional[Dict[str, Any]] = None,
) -> MaterialEvent:
    return MaterialEvent(
        timestamp=datetime.now().isoformat(timespec='seconds'),
        source_type=source_type,
        title=title,
        summary=MessageCompressor.compress(summary),
        project=project,
        evidence=evidence or [],
        tags=tags or [],
        outcome=ResponseSummarizer.summarize(outcome) if outcome else "",
        next_actions=next_actions or [],
        content=MessageCompressor.compress(content) if content else "",
        metadata=metadata or {},
    )


def _build_arg_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Capture a conversation material for week reports.")
    parser.add_argument("--project", default="", help="Project or workstream name")
    parser.add_argument("--tag", action="append", default=[], help="Tag, repeatable")
    parser.add_argument("--evidence", action="append", default=[], help="Evidence item, repeatable")
    parser.add_argument("--next-action", action="append", default=[], help="Next action, repeatable")
    parser.add_argument("--user-message", required=True, help="Original user message")
    parser.add_argument("--assistant-response", required=True, help="Assistant response")
    return parser


def main() -> int:
    parser = _build_arg_parser()
    args = parser.parse_args()

    git = create_git_manager()
    if not git:
        logger.error("Missing Git environment variables for week report system")
        return 1

    recorder = WeekReportRecorder(git)
    success = recorder.record_conversation(
        args.user_message,
        args.assistant_response,
        project=args.project,
        tags=args.tag,
        evidence=args.evidence,
        next_actions=args.next_action,
    )
    return 0 if success else 1


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""
Git Operations for Week Report System

This script handles all Git-related operations including:
- Repository cloning and pulling
- Conflict resolution with automatic retry
- Conversation file management
"""

import os
import subprocess
import time
import logging
from typing import Optional
from pathlib import Path

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)


class GitOperationError(Exception):
    """Custom exception for Git operation failures."""
    pass


class PushConflictError(GitOperationError):
    """Exception raised when push fails due to remote changes."""
    pass


class GitManager:
    """Manages Git operations for the week report system."""

    def __init__(
        self,
        username: str,
        token: str,
        repo: str,
        local_path: Optional[str] = None
    ):
        """
        Initialize Git manager.

        Args:
            username: GitHub username
            token: GitHub personal access token
            repo: Repository name in format "username/repo"
            local_path: Local path for repository (default: ~/.week-report-repo)
        """
        self.username = username
        self.token = token
        self.repo = repo
        self.repo_url = f"https://{username}:{token}@github.com/{repo}.git"
        self.local_path = local_path or os.path.expanduser("~/.week-report-repo")
        self.repo_path = os.path.join(self.local_path, repo.split('/')[-1])

    def _run_git_command(self, *args, retry_on_conflict: bool = False) -> tuple:
        """
        Run a git command and return (success, output, error).

        Args:
            *args: Git command arguments
            retry_on_conflict: Whether to handle conflicts automatically

        Returns:
            Tuple of (success: bool, stdout: str, stderr: str)
        """
        cmd = ['git'] + list(args)
        logger.debug(f"Running: git {' '.join(args)}")

        try:
            result = subprocess.run(
                cmd,
                cwd=self.repo_path,
                capture_output=True,
                text=True,
                timeout=60
            )

            if result.returncode != 0:
                error_msg = result.stderr.strip()

                # Check for push conflict
                if 'non-fast-forward' in error_msg or 'fetch first' in error_msg:
                    if retry_on_conflict:
                        raise PushConflictError("Remote has new commits")
                    return False, result.stdout, error_msg

                logger.error(f"Git command failed: {error_msg}")
                return False, result.stdout, error_msg

            return True, result.stdout, result.stderr

        except subprocess.TimeoutExpired:
            logger.error("Git command timed out")
            return False, "", "Command timed out"
        except Exception as e:
            logger.error(f"Git command exception: {str(e)}")
            return False, "", str(e)

    def is_repo_initialized(self) -> bool:
        """Check if repository is already cloned."""
        return os.path.exists(os.path.join(self.repo_path, '.git'))

    def clone(self) -> bool:
        """Clone the repository, cleaning up any corrupt local state first."""
        import shutil
        try:
            os.makedirs(self.local_path, exist_ok=True)

            # If directory exists but has no .git, it's corrupt — remove and re-clone
            if os.path.exists(self.repo_path) and not os.path.exists(os.path.join(self.repo_path, '.git')):
                logger.warning(f"Directory exists but is not a git repo, removing: {self.repo_path}")
                shutil.rmtree(self.repo_path)

            cmd = ['git', 'clone', self.repo_url, self.repo_path]
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)

            if result.returncode != 0:
                # Empty repo is OK — init locally and point at remote
                if 'empty repository' in result.stderr or 'repository is empty' in result.stderr.lower():
                    logger.info("Repository is empty, initializing locally")
                    os.makedirs(self.repo_path, exist_ok=True)
                    subprocess.run(['git', 'init'], cwd=self.repo_path, capture_output=True)
                    subprocess.run(['git', 'remote', 'add', 'origin', self.repo_url],
                                   cwd=self.repo_path, capture_output=True)
                    return True
                logger.error(f"Clone failed: {result.stderr}")
                return False

            logger.info(f"Repository cloned to {self.repo_path}")
            return True

        except Exception as e:
            logger.error(f"Clone exception: {str(e)}")
            return False

    def pull(self, force: bool = False) -> bool:
        """
        Pull latest changes from remote.

        Args:
            force: If True, reset local changes before pulling

        Returns:
            True if successful, False otherwise
        """
        if not self.is_repo_initialized():
            return self.clone()

        try:
            if force:
                # Reset any local changes
                self._run_git_command('reset', '--hard', 'HEAD')
                self._run_git_command('clean', '-fd')

            # Fetch and merge
            success, _, error = self._run_git_command('pull', '--rebase', 'origin', 'main')

            if not success:
                # Try 'master' branch if 'main' fails
                success, _, _ = self._run_git_command('pull', '--rebase', 'origin', 'master')

            return success

        except Exception as e:
            logger.error(f"Pull failed: {str(e)}")
            return False

    def push(self) -> bool:
        """Push changes to remote."""
        # Try main branch first, then master
        success, _, _ = self._run_git_command('push', 'origin', 'main')

        if not success:
            success, _, _ = self._run_git_command('push', 'origin', 'master')

        if not success:
            raise PushConflictError("Push failed - remote may have new commits")

        return True

    def commit_and_push(self, message: str, max_retries: int = 3) -> bool:
        """
        Commit and push changes with automatic retry on conflicts.

        Separates commit (done once) from push (retried on conflict).

        Args:
            message: Commit message
            max_retries: Maximum number of retry attempts for push

        Returns:
            True if successful, False otherwise
        """
        try:
            # Stage and commit once
            self._run_git_command('add', '-A')
            success, _, _ = self._run_git_command('commit', '-m', message)
            if not success:
                # Nothing to commit
                return True
        except Exception as e:
            logger.error(f"Commit failed: {str(e)}")
            return False

        # Push with retry on conflict
        for attempt in range(max_retries):
            try:
                self.push()
                logger.info(f"Successfully committed and pushed: {message}")
                return True

            except PushConflictError:
                if attempt < max_retries - 1:
                    logger.warning(f"Push conflict, retrying ({attempt + 1}/{max_retries})")
                    time.sleep(1)
                    self.pull()  # Rebase local commit on top of remote changes
                else:
                    logger.error("Max retries reached, giving up")
                    return False

            except Exception as e:
                logger.error(f"Push failed: {str(e)}")
                return False

        return False

    def append_to_file(self, file_path: str, content: str) -> bool:
        """
        Append content to a file in the repository.

        Args:
            file_path: Relative path from repo root
            content: Content to append

        Returns:
            True if successful
        """
        full_path = os.path.join(self.repo_path, file_path)

        # Create directory if needed
        os.makedirs(os.path.dirname(full_path), exist_ok=True)

        # Append content
        with open(full_path, 'a', encoding='utf-8') as f:
            f.write(content)

        return True

    def read_file(self, file_path: str) -> Optional[str]:
        """Read file content from repository."""
        full_path = os.path.join(self.repo_path, file_path)

        if not os.path.exists(full_path):
            return None

        with open(full_path, 'r', encoding='utf-8') as f:
            return f.read()

    def list_files(self, directory: str = "") -> list:
        """List all files in a directory."""
        full_path = os.path.join(self.repo_path, directory)

        if not os.path.exists(full_path):
            return []

        files = []
        for root, _, filenames in os.walk(full_path):
            for filename in filenames:
                if filename.endswith('.txt'):
                    rel_path = os.path.relpath(os.path.join(root, filename), self.repo_path)
                    files.append(rel_path)

        return files


def create_git_manager() -> Optional[GitManager]:
    """
    Create a GitManager instance from environment variables.

    Returns:
        GitManager if all env vars are set, None otherwise
    """
    username = os.environ.get('WEEK_REPORT_GIT_USERNAME')
    token = os.environ.get('WEEK_REPORT_GIT_PERSONAL_TOKEN')
    repo = os.environ.get('WEEK_REPORT_GIT_REPO')

    if not all([username, token, repo]):
        logger.warning("Missing environment variables for Git configuration")
        return None

    return GitManager(username, token, repo)


# CLI interface for testing
if __name__ == "__main__":
    import sys

    if len(sys.argv) < 2:
        print("Usage: python git_operations.py <command> [args]")
        print("Commands: clone, pull, status")
        sys.exit(1)

    command = sys.argv[1]

    git = create_git_manager()
    if not git:
        print("Error: Please set environment variables first")
        sys.exit(1)

    if command == "clone":
        success = git.clone()
        print(f"Clone: {'Success' if success else 'Failed'}")

    elif command == "pull":
        success = git.pull()
        print(f"Pull: {'Success' if success else 'Failed'}")

    elif command == "status":
        if git.is_repo_initialized():
            print(f"Repository initialized at: {git.repo_path}")
            files = git.list_files()
            print(f"Files: {len(files)}")
        else:
            print("Repository not initialized")

#!/usr/bin/env python3
"""
CLI for explicitly ingesting weekly report materials.
"""

import argparse
import logging
from typing import Dict

try:
    from conversation_logger import WeekReportRecorder, build_material_event
    from git_operations import create_git_manager
except ImportError:  # pragma: no cover - script/package dual use
    from .conversation_logger import WeekReportRecorder, build_material_event
    from .git_operations import create_git_manager


logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)


def _parse_metadata(entries) -> Dict[str, str]:
    metadata: Dict[str, str] = {}
    for item in entries:
        if "=" not in item:
            metadata[item] = ""
            continue
        key, value = item.split("=", 1)
        metadata[key] = value
    return metadata


def _build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Ingest a material into the week report repository.")
    subparsers = parser.add_subparsers(dest="source_type", required=True)

    conversation = subparsers.add_parser("conversation", help="Capture a conversation material")
    conversation.add_argument("--project", default="")
    conversation.add_argument("--tag", action="append", default=[])
    conversation.add_argument("--evidence", action="append", default=[])
    conversation.add_argument("--next-action", action="append", default=[])
    conversation.add_argument("--user-message", required=True)
    conversation.add_argument("--assistant-response", required=True)

    for name in ["document", "repo-activity"]:
        parser_i = subparsers.add_parser(name, help=f"Capture a {name} material")
        parser_i.add_argument("--project", default="")
        parser_i.add_argument("--title", required=True)
        parser_i.add_argument("--summary", required=True)
        parser_i.add_argument("--outcome", default="")
        parser_i.add_argument("--content", default="")
        parser_i.add_argument("--tag", action="append", default=[])
        parser_i.add_argument("--evidence", action="append", default=[])
        parser_i.add_argument("--next-action", action="append", default=[])
        parser_i.add_argument("--metadata", action="append", default=[], help="key=value, repeatable")

    return parser


def main() -> int:
    parser = _build_parser()
    args = parser.parse_args()

    git = create_git_manager()
    if not git:
        logger.error("Missing Git environment variables for week report system")
        return 1

    recorder = WeekReportRecorder(git)

    if args.source_type == "conversation":
        success = recorder.record_conversation(
            args.user_message,
            args.assistant_response,
            project=args.project,
            tags=args.tag,
            evidence=args.evidence,
            next_actions=args.next_action,
        )
        return 0 if success else 1

    source_type = "repo_activity" if args.source_type == "repo-activity" else "document"
    event = build_material_event(
        source_type=source_type,
        title=args.title,
        summary=args.summary,
        project=args.project,
        tags=args.tag,
        evidence=args.evidence,
        outcome=args.outcome,
        next_actions=args.next_action,
        content=args.content,
        metadata=_parse_metadata(args.metadata),
    )
    success = recorder.record_event(event)
    return 0 if success else 1


if __name__ == "__main__":
    raise SystemExit(main())