full-stack-coding-assistant-agent 0.1.0__py3-none-any.whl

full_stack_coding_assistant_agent-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agents/audit_agent.py,sha256=4kcUpK-fSoCdKHKbjmSi0D-9DS6auFLReGmBizWD--4,7059
+agents/backend_agent.py,sha256=lQak0WjlIuIpzK0nFPbWKgCsEBj-q8ApMCkRXmx2DBA,5472
+agents/base_agent.py,sha256=HCmTz1whO8-IYpyWYRuN3HQTZmc7Xw7a0NiEojv_ovQ,12454
+agents/frontend_agent.py,sha256=hafysLpHS1WOnPp4Mxe_d4MKbyZu9yu1a64yCdHefV4,4524
+agents/test_agent.py,sha256=0nviTiSEJQUf-MrnGJ6YqABDvELTo6IYeouS1KhyHBM,4380
+coordinator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+coordinator/coordinator.py,sha256=m52zM5D5v9zeJ0OVUNF1Gs8zTvcXQm-ZbbzsDyFB08o,16385
+coordinator/dag.py,sha256=hSy9_uCyL3_bxN9cZTmhno4tOLLHTB_fGlZNFXo--EU,4818
+executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+executor/cb_integration.py,sha256=MZdEnCWXdB9pvDa_r8-WEsCqeRd8hp3HRyN0gkXlKns,4224
+full_stack_coding_assistant_agent/__init__.py,sha256=EoE-_WS5X4mGr52rjGsO3FTIEC7Ui9cVAc2g777LmNY,114
+full_stack_coding_assistant_agent/cli.py,sha256=BRoGBOQVrTF0_Q4kJF1guFNVbkrI7_ENxoutZIgL-bs,142
+full_stack_coding_assistant_agent/main.py,sha256=Bhj_b-EYVPEkDuK3EUT1n_tx5rmrOcdoKHpj80pBfA8,21772
+model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+model/config.py,sha256=QpXv3X3IyumOi2kzm_7bUi8r73991pUi_ABV6XB0HlE,1814
+model/model_router.py,sha256=inyUbcjIItyY138zSus3ak9rtgyPvGzS1wuE6sPzZBU,5059
+storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+storage/context_db.py,sha256=4nJ4tyjUeSidFB547056ajnJdCqq1acJKEtyHmraQHc,8818
+utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utils/agent_selector.py,sha256=lKdcQM28jMZX-PM4jnAhaRf5tztH2tHRdDtAB2PCG-c,8447
+utils/config_validator.py,sha256=7_ht_CFyMo5uWxe9VURyUvEBodgkkHreK6KXth3CDZE,4110
+utils/logger.py,sha256=weInUPgk8cVYqOGo1LY31wDWSI7yjRfbWHoqA4bJHcE,2390
+utils/output_manager.py,sha256=C-OhNPkuxhUsxwteRc2NVGlndDazOsHTalw249r8gEU,56878
+utils/pdf_reader.py,sha256=Zusotq6Rcb7mCEQfpLREsUQeygb0wFxtnQyTT8j2zYk,3575
+utils/version.py,sha256=Qgv710glSRpnC3c4hDgkGL7MGU5pVmYbUhtLDIXmdrA,5423
+full_stack_coding_assistant_agent-0.1.0.dist-info/METADATA,sha256=WsOEKwvuSbhsmzxEw3O_Uujs6GFFQIyPbGMRS2JQPc0,26780
+full_stack_coding_assistant_agent-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+full_stack_coding_assistant_agent-0.1.0.dist-info/entry_points.txt,sha256=aQQuGx1UwVXvNCMee2CfKndddXpOWFLp5KQsA7puXAQ,69
+full_stack_coding_assistant_agent-0.1.0.dist-info/top_level.txt,sha256=sKrNm57RWmXu0BlnT_LN0PVRdTwmbokTSgdpeNY4goQ,82
+full_stack_coding_assistant_agent-0.1.0.dist-info/RECORD,,

full_stack_coding_assistant_agent-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

full_stack_coding_assistant_agent-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fscaa = full_stack_coding_assistant_agent.cli:main

full_stack_coding_assistant_agent-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,7 @@
+agents
+coordinator
+executor
+full_stack_coding_assistant_agent
+model
+storage
+utils

model/config.py

@@ -0,0 +1,62 @@
+"""
+模型配置文件
+定义各 Agent 使用的模型及 Fallback 策略
+支持从环境变量读取敏感信息
+"""
+
+import os
+
+from dotenv import load_dotenv
+
+# 加载 .env 文件中的环境变量
+load_dotenv(override=True)  # 允许 .env 覆盖系统环境变量
+
+
+def get_env(key: str, default: str = "") -> str:
+    """安全获取环境变量"""
+    return os.getenv(key, default)
+
+
+# 从环境变量读取敏感配置
+TENCENT_API_KEY = get_env("TENCENT_API_KEY", "YOUR_TENCENT_API_KEY")
+TENCENT_API_BASE = get_env(
+    "TENCENT_API_BASE", "https://api.hunyuan.cloud.tencent.com/v1"
+)
+SQLITE_DB_PATH = get_env("SQLITE_DB_PATH", "./context.db")
+CODEBUDDY_CLI_PATH = get_env("CODEBUDDY_CLI_PATH", "codebuddy")
+CODEBUDDY_TIMEOUT = int(get_env("CODEBUDDY_TIMEOUT", "60"))
+
+MODEL_CONFIG = {
+    # 默认模型（腾讯混元，OpenAI 兼容 API）
+    "default": "openai/hunyuan-lite",
+    # 各 Agent 专用模型配置
+    "agents": {
+        "frontend": "openai/hunyuan-lite",  # 前端 Agent 使用轻量模型
+        "backend": "openai/hunyuan-standard",  # 后端 Agent 使用标准模型
+        "test": "openai/hunyuan-lite",  # 测试 Agent 使用轻量模型
+        "audit": "openai/hunyuan-pro",  # 审计 Agent 使用专业模型
+    },
+    # 腾讯混元 API 配置（从环境变量读取）
+    "tencent": {
+        "api_base": TENCENT_API_BASE,
+        "api_key": TENCENT_API_KEY,
+    },
+    # Fallback 链式降级策略
+    "fallback_chain": ["openai/hunyuan-lite", "openai/hunyuan-standard"],
+    # LiteLLM 通用参数
+    "litellm_settings": {
+        "timeout": 60,
+        "max_retries": 2,
+    },
+}
+
+# 数据库配置
+DATABASE_CONFIG = {
+    "path": SQLITE_DB_PATH,
+}
+
+# CodeBuddy CLI 配置
+CODEBUDDY_CONFIG = {
+    "cli_path": CODEBUDDY_CLI_PATH,
+    "timeout": CODEBUDDY_TIMEOUT,
+}

model/model_router.py

@@ -0,0 +1,150 @@
+"""
+模型路由器 - 基于 LiteLLM 的统一模型接口
+支持多模型切换、Fallback、流式输出、Token 用量追踪
+"""
+
+import time
+from typing import Dict, Generator, List, Optional
+
+import litellm
+
+from model.config import MODEL_CONFIG
+
+
+def _extract_usage(response) -> Dict:
+    """安全提取 LiteLLM response 中的 usage 信息"""
+    try:
+        usage = response.usage
+        if usage is None:
+            return {}
+        return {
+            "prompt_tokens": getattr(usage, "prompt_tokens", 0) or 0,
+            "completion_tokens": getattr(usage, "completion_tokens", 0) or 0,
+            "total_tokens": getattr(usage, "total_tokens", 0) or 0,
+        }
+    except Exception:
+        return {}
+
+
+class ModelRouter:
+    """LiteLLM 封装，提供统一的模型调用接口"""
+
+    def __init__(self):
+        self.config = MODEL_CONFIG
+        self.default_model = self.config["default"]
+        self.fallback_chain = self.config["fallback_chain"]
+
+        # 配置 LiteLLM
+        litellm.api_key = self.config["tencent"]["api_key"]
+        litellm.api_base = self.config["tencent"]["api_base"]
+
+    def chat(
+        self,
+        messages: List[Dict],
+        model: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> Dict:
+        """
+        统一聊天接口（非流式）
+
+        Args:
+            messages: OpenAI 格式的消息列表
+            model: 指定模型，None 则使用默认模型
+            temperature: 温度参数
+            max_tokens: 最大 token 数
+
+        Returns:
+            字典 {"content": str, "usage": dict, "model": str, "latency_ms": float}
+            usage 包含 prompt_tokens / completion_tokens / total_tokens
+        """
+        model = model or self.default_model
+
+        def _make_empty_result(content: str) -> Dict:
+            return {
+                "content": content,
+                "usage": {},
+                "model": model,
+                "latency_ms": 0,
+            }
+
+        try:
+            t0 = time.time()
+            response = litellm.completion(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **self.config["litellm_settings"],
+            )
+            latency = (time.time() - t0) * 1000
+            return {
+                "content": response.choices[0].message.content or "",
+                "usage": _extract_usage(response),
+                "model": model,
+                "latency_ms": round(latency, 1),
+            }
+        except Exception as e:
+            import logging
+
+            logger = logging.getLogger("coding_agent")
+            logger.error(f"LLM 调用失败 (model={model}): {e}")
+            # Fallback 策略
+            for fallback_model in self.fallback_chain:
+                if fallback_model != model:
+                    try:
+                        logger.warning(f"尝试 Fallback 模型: {fallback_model}")
+                        t0 = time.time()
+                        response = litellm.completion(
+                            model=fallback_model,
+                            messages=messages,
+                            temperature=temperature,
+                            max_tokens=max_tokens,
+                        )
+                        latency = (time.time() - t0) * 1000
+                        return {
+                            "content": response.choices[0].message.content or "",
+                            "usage": _extract_usage(response),
+                            "model": fallback_model,
+                            "latency_ms": round(latency, 1),
+                        }
+                    except Exception as fe:
+                        logger.warning(f"Fallback 模型 {fallback_model} 也失败: {fe}")
+                        continue
+            raise RuntimeError(
+                f"所有模型调用失败 (model={model}, fallback={self.fallback_chain}): {str(e)}"
+            )
+
+    def stream_chat(
+        self,
+        messages: List[Dict],
+        model: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> Generator[str, None, None]:
+        """
+        流式聊天接口
+
+        Yields:
+            流式输出的文本片段
+        """
+        model = model or self.default_model
+
+        try:
+            response = litellm.completion(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=True,
+            )
+            for chunk in response:
+                content = chunk.choices[0].delta.content
+                if content:
+                    yield content
+        except Exception as e:
+            yield f"[ERROR] 模型调用失败: {str(e)}"
+
+    def get_model_for_agent(self, agent_type: str) -> str:
+        """获取指定 Agent 类型的模型"""
+        return self.config["agents"].get(agent_type, self.default_model)

storage/context_db.py

@@ -0,0 +1,274 @@
+"""
+SQLite 上下文数据库操作封装
+零部署方案 - 整个数据库是一个文件
+支持 Python 3.13+ 的最新 SQLite 特性
+"""
+
+import json
+import sqlite3
+from typing import Dict, List, Optional
+
+from model.config import DATABASE_CONFIG
+
+
+class ContextDB:
+    """SQLite 上下文数据库操作类 (Python 3.13+ 优化版)"""
+
+    def __init__(self, db_path: Optional[str] = None):
+        """
+        初始化数据库
+
+        Args:
+            db_path: 数据库路径，None 则使用配置文件中的默认值
+        """
+        self.db_path = db_path or DATABASE_CONFIG["path"]
+        self._init_db()
+
+    def _get_connection(self):
+        """获取数据库连接 (Python 3.13+ 优化)"""
+        conn = sqlite3.connect(self.db_path)
+        # Python 3.13+ 支持更多 SQLite pragma 设置
+        conn.execute("PRAGMA journal_mode=WAL")  # 提升并发性能
+        conn.execute("PRAGMA foreign_keys=ON")  # 启用外键约束
+        conn.execute("PRAGMA busy_timeout=5000")  # 5秒忙等待
+        return conn
+
+    def _init_db(self):
+        """初始化数据库，执行 schema.sql"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+
+        # 创建 tables（如果不存在）
+        cursor.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS tasks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                task_id TEXT UNIQUE NOT NULL,
+                description TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'pending',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                result TEXT,
+                error TEXT
+            );
+
+            CREATE TABLE IF NOT EXISTS code_changes (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                task_id TEXT NOT NULL,
+                agent_type TEXT NOT NULL,
+                file_path TEXT NOT NULL,
+                change_type TEXT NOT NULL,
+                diff TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (task_id) REFERENCES tasks(task_id)
+            );
+
+            CREATE TABLE IF NOT EXISTS api_contracts (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                task_id TEXT NOT NULL,
+                endpoint TEXT NOT NULL,
+                method TEXT NOT NULL,
+                request_schema TEXT,
+                response_schema TEXT,
+                status TEXT DEFAULT 'draft',
+                created_by TEXT NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (task_id) REFERENCES tasks(task_id)
+            );
+
+            CREATE TABLE IF NOT EXISTS audit_reports (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                task_id TEXT NOT NULL,
+                agent_type TEXT NOT NULL,
+                severity TEXT NOT NULL,
+                message TEXT NOT NULL,
+                file_path TEXT,
+                line_number INTEGER,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (task_id) REFERENCES tasks(task_id)
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+            CREATE INDEX IF NOT EXISTS idx_code_changes_task_id ON code_changes(task_id);
+            CREATE INDEX IF NOT EXISTS idx_api_contracts_task_id ON api_contracts(task_id);
+            CREATE INDEX IF NOT EXISTS idx_audit_reports_task_id ON audit_reports(task_id);
+        """
+        )
+
+        conn.commit()
+        conn.close()
+
+    # ==================== Task 操作 ====================
+
+    def create_task(self, task_id: str, description: str) -> int:
+        """创建新任务"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO tasks (task_id, description) VALUES (?, ?)",
+            (task_id, description),
+        )
+        task_pk = cursor.lastrowid
+        conn.commit()
+        conn.close()
+        return task_pk
+
+    def update_task_status(
+        self,
+        task_id: str,
+        status: str,
+        result: Optional[str] = None,
+        error: Optional[str] = None,
+    ):
+        """更新任务状态"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            """UPDATE tasks
+               SET status = ?, result = ?, error = ?, updated_at = CURRENT_TIMESTAMP
+               WHERE task_id = ?""",
+            (status, result, error, task_id),
+        )
+        conn.commit()
+        conn.close()
+
+    def get_task(self, task_id: str) -> Optional[Dict]:
+        """获取任务详情"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM tasks WHERE task_id = ?", (task_id,))
+        row = cursor.fetchone()
+        conn.close()
+
+        if row:
+            columns = [
+                "id",
+                "task_id",
+                "description",
+                "status",
+                "created_at",
+                "updated_at",
+                "result",
+                "error",
+            ]
+            return dict(zip(columns, row))
+        return None
+
+    # ==================== Code Changes 操作 ====================
+
+    def log_code_change(
+        self,
+        task_id: str,
+        agent_type: str,
+        file_path: str,
+        change_type: str,
+        diff: Optional[str] = None,
+    ):
+        """记录代码变更"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            """INSERT INTO code_changes
+               (task_id, agent_type, file_path, change_type, diff)
+               VALUES (?, ?, ?, ?, ?)""",
+            (task_id, agent_type, file_path, change_type, diff),
+        )
+        conn.commit()
+        conn.close()
+
+    # ==================== API Contracts 操作 ====================
+
+    def save_api_contract(
+        self,
+        task_id: str,
+        endpoint: str,
+        method: str,
+        request_schema: Optional[Dict] = None,
+        response_schema: Optional[Dict] = None,
+        created_by: str = "backend",
+    ):
+        """保存前后端接口契约"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            """INSERT INTO api_contracts
+               (task_id, endpoint, method, request_schema, response_schema, created_by)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (
+                task_id,
+                endpoint,
+                method,
+                json.dumps(request_schema) if request_schema else None,
+                json.dumps(response_schema) if response_schema else None,
+                created_by,
+            ),
+        )
+        conn.commit()
+        conn.close()
+
+    def get_api_contracts(self, task_id: str) -> List[Dict]:
+        """获取任务的接口契约列表"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM api_contracts WHERE task_id = ?", (task_id,))
+        rows = cursor.fetchall()
+        conn.close()
+
+        columns = [
+            "id",
+            "task_id",
+            "endpoint",
+            "method",
+            "request_schema",
+            "response_schema",
+            "status",
+            "created_by",
+            "created_at",
+        ]
+        return [dict(zip(columns, row)) for row in rows]
+
+    # ==================== Audit Reports 操作 ====================
+
+    def add_audit_report(
+        self,
+        task_id: str,
+        agent_type: str,
+        severity: str,
+        message: str,
+        file_path: Optional[str] = None,
+        line_number: Optional[int] = None,
+    ):
+        """添加审计意见"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            """INSERT INTO audit_reports
+               (task_id, agent_type, severity, message, file_path, line_number)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (task_id, agent_type, severity, message, file_path, line_number),
+        )
+        conn.commit()
+        conn.close()
+
+    def get_audit_reports(self, task_id: str) -> List[Dict]:
+        """获取任务的审计报告"""
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT * FROM audit_reports WHERE task_id = ? ORDER BY severity",
+            (task_id,),
+        )
+        rows = cursor.fetchall()
+        conn.close()
+
+        columns = [
+            "id",
+            "task_id",
+            "agent_type",
+            "severity",
+            "message",
+            "file_path",
+            "line_number",
+            "created_at",
+        ]
+        return [dict(zip(columns, row)) for row in rows]