tradingcodex 0.1.0__py3-none-any.whl

tradingcodex_cli/commands/research.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tradingcodex_service.application.research import (
+    create_research_artifact,
+    export_research_artifact_md,
+    get_research_artifact,
+    append_research_artifact_version,
+    list_research_artifacts,
+    search_research_artifacts,
+)
+from tradingcodex_cli.commands.utils import _option_value, print_json
+
+def research(root: Path, argv: list[str]) -> None:
+    sub = argv[0] if argv else "list"
+    args = argv[1:]
+    if sub == "create":
+        markdown_file = _option_value(args, "--markdown-file") or _option_value(args, "--file")
+        if not markdown_file:
+            raise ValueError("Usage: tcx research create --markdown-file <file.md> [--id <id>] [--title <title>] [--source-as-of <date>]")
+        payload = {
+            "artifact_id": _option_value(args, "--id"),
+            "artifact_type": _option_value(args, "--type") or "research_memo",
+            "universe": _option_value(args, "--universe") or "public_equity",
+            "workflow_type": _option_value(args, "--workflow-type") or "",
+            "symbol": _option_value(args, "--symbol") or "",
+            "title": _option_value(args, "--title"),
+            "markdown_path": markdown_file,
+            "source_as_of": _option_value(args, "--source-as-of") or "",
+            "readiness_label": _option_value(args, "--readiness") or "",
+            "created_by": _option_value(args, "--created-by") or "head-manager",
+            "export_path": _option_value(args, "--export-path"),
+        }
+        print_json(create_research_artifact(root, payload))
+        return
+    if sub == "append":
+        artifact_id = args[0] if args and not args[0].startswith("--") else _option_value(args, "--id")
+        markdown_file = _option_value(args, "--markdown-file") or _option_value(args, "--file")
+        if not artifact_id or not markdown_file:
+            raise ValueError("Usage: tcx research append <artifact-id> --markdown-file <file.md> [--source-as-of <date>]")
+        print_json(append_research_artifact_version(root, {
+            "artifact_id": artifact_id,
+            "markdown_path": markdown_file,
+            "source_as_of": _option_value(args, "--source-as-of") or "",
+            "created_by": _option_value(args, "--created-by") or "head-manager",
+            "export_path": _option_value(args, "--export-path"),
+        }))
+        return
+    if sub == "get":
+        artifact_id = args[0] if args and not args[0].startswith("--") else _option_value(args, "--id")
+        if not artifact_id:
+            raise ValueError("Usage: tcx research get <artifact-id>")
+        print_json(get_research_artifact(root, {"artifact_id": artifact_id}))
+        return
+    if sub == "list":
+        print_json(list_research_artifacts(root, {
+            "artifact_type": _option_value(args, "--type"),
+            "universe": _option_value(args, "--universe"),
+            "symbol": _option_value(args, "--symbol"),
+            "limit": _option_value(args, "--limit") or 50,
+        }))
+        return
+    if sub == "search":
+        query = " ".join(args).strip()
+        if not query:
+            raise ValueError("Usage: tcx research search <query>")
+        print_json(search_research_artifacts(root, {"query": query}))
+        return
+    if sub == "export":
+        artifact_id = args[0] if args and not args[0].startswith("--") else _option_value(args, "--id")
+        if not artifact_id:
+            raise ValueError("Usage: tcx research export <artifact-id> [--export-path <file.md>]")
+        print_json(export_research_artifact_md(root, {"artifact_id": artifact_id, "export_path": _option_value(args, "--export-path")}))
+        return
+    raise ValueError(f"Unknown research command: {sub}")

tradingcodex_cli/commands/skills.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tradingcodex_cli.commands.utils import _option_value, apply_skill_proposal, list_skills, print_json, write_skill_proposal
+from tradingcodex_service.application.agents import (
+    create_or_update_optional_skill,
+    delete_optional_skill,
+    get_optional_skill_record,
+    read_optional_skill_records,
+    set_optional_skill_status,
+)
+
+def skills(root: Path, argv: list[str]) -> None:
+    sub = argv[0] if argv else "list"
+    args = argv[1:]
+    if sub == "optional":
+        optional_skills(root, args)
+        return
+    if sub == "list":
+        for skill in list_skills(root, include_internal="--all" in args):
+            print(skill)
+        return
+    if sub == "inspect":
+        name = args[0] if args else ""
+        from tradingcodex_service.application.agents import build_projection_state
+
+        skill = build_projection_state(root)["skills"].get(name)
+        if not skill or not skill.get("source_file"):
+            raise ValueError(f"Unknown skill: {name}")
+        print((root / str(skill["source_file"])).read_text(encoding="utf-8"))
+        return
+    if sub in {"propose-add", "propose-update"}:
+        target = _option_value(args, "--to")
+        skill = _option_value(args, "--skill")
+        if not target or not skill:
+            raise ValueError(f"Usage: tcx skills {sub} --to <agent> --skill <skill>")
+        print_json(write_skill_proposal(root, sub.replace("propose-", ""), target, skill))
+        return
+    if sub == "apply-proposal":
+        proposal_path = Path(args[0]) if args else None
+        if not proposal_path:
+            raise ValueError("Usage: tcx skills apply-proposal <proposal.yaml> [--approved-by <principal>]")
+        apply_skill_proposal(root, proposal_path if proposal_path.is_absolute() else root / proposal_path, _option_value(args, "--approved-by"))
+        return
+    raise ValueError(f"Unknown skills command: {sub}")
+
+
+def optional_skills(root: Path, argv: list[str]) -> None:
+    sub = argv[0] if argv else "list"
+    args = argv[1:]
+    role = _option_value(args, "--role") or _option_value(args, "--to")
+    if sub == "list":
+        for record in read_optional_skill_records(root, role=role, include_archived="--active" not in args):
+            print(f"{record['role']}:{record['name']}")
+        return
+    if sub == "inspect":
+        name = args[0] if args and not args[0].startswith("--") else ""
+        if not role or not name:
+            raise ValueError("Usage: tcx skills optional inspect <name> --role <agent>")
+        record = get_optional_skill_record(root, role, name)
+        print((root / str(record["source_file"])).read_text(encoding="utf-8"))
+        return
+    if sub in {"create", "update"}:
+        name = args[0] if args and not args[0].startswith("--") else ""
+        if not role or not name:
+            raise ValueError(f"Usage: tcx skills optional {sub} <name> --role <agent> [--description <text>] [--body-file <path>]")
+        body = _body_arg(root, args)
+        status = "active" if "--active" in args else (_option_value(args, "--status") or "draft")
+        print_json(create_or_update_optional_skill(root, role, name, description=_option_value(args, "--description") or "", body=body, status=status, actor="local-cli"))
+        return
+    if sub in {"activate", "archive"}:
+        name = args[0] if args else ""
+        if not role or not name:
+            raise ValueError(f"Usage: tcx skills optional {sub} <name> --role <agent>")
+        print_json(set_optional_skill_status(root, role, name, "active" if sub == "activate" else "archived", actor="local-cli"))
+        return
+    if sub == "delete":
+        name = args[0] if args else ""
+        if not role or not name:
+            raise ValueError("Usage: tcx skills optional delete <name> --role <agent> [--force]")
+        print_json(delete_optional_skill(root, role, name, force="--force" in args, actor="local-cli"))
+        return
+    raise ValueError(f"Unknown optional skills command: {sub}")
+
+
+def _body_arg(root: Path, args: list[str]) -> str:
+    body_file = _option_value(args, "--body-file")
+    if body_file:
+        path = Path(body_file)
+        path = path if path.is_absolute() else root / path
+        return path.read_text(encoding="utf-8")
+    return _option_value(args, "--body") or ""

tradingcodex_cli/commands/strategies.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tradingcodex_cli.commands.utils import _option_value, print_json
+from tradingcodex_service.application.agents import (
+    create_or_update_strategy_skill,
+    delete_strategy_skill,
+    get_strategy_skill_record,
+    read_strategy_skill_records,
+    set_strategy_skill_status,
+)
+
+
+def strategies(root: Path, argv: list[str]) -> None:
+    sub = argv[0] if argv else "list"
+    args = argv[1:]
+    if sub == "list":
+        for record in read_strategy_skill_records(root, active_only="--active" in args):
+            print(record["name"])
+        return
+    if sub == "inspect":
+        name = args[0] if args else ""
+        if not name:
+            raise ValueError("Usage: tcx strategies inspect <name>")
+        record = get_strategy_skill_record(root, name)
+        print((root / str(record["source_file"])).read_text(encoding="utf-8"))
+        return
+    if sub in {"create", "update"}:
+        name = args[0] if args and not args[0].startswith("--") else ""
+        if not name:
+            raise ValueError(f"Usage: tcx strategies {sub} <name> [--description <text>] [--body-file <path>]")
+        status = "active" if "--active" in args else (_option_value(args, "--status") or "draft")
+        print_json(
+            create_or_update_strategy_skill(
+                root,
+                name,
+                description=_option_value(args, "--description") or "",
+                body=_body_arg(root, args),
+                language=_option_value(args, "--language") or "unknown",
+                status=status,
+                actor="local-cli",
+            )
+        )
+        return
+    if sub in {"activate", "archive"}:
+        name = args[0] if args else ""
+        if not name:
+            raise ValueError(f"Usage: tcx strategies {sub} <name>")
+        print_json(set_strategy_skill_status(root, name, "active" if sub == "activate" else "archived", actor="local-cli"))
+        return
+    if sub == "delete":
+        name = args[0] if args else ""
+        if not name:
+            raise ValueError("Usage: tcx strategies delete <name> [--force]")
+        print_json(delete_strategy_skill(root, name, force="--force" in args, actor="local-cli"))
+        return
+    raise ValueError(f"Unknown strategies command: {sub}")
+
+
+def _body_arg(root: Path, args: list[str]) -> str:
+    body_file = _option_value(args, "--body-file")
+    if body_file:
+        path = Path(body_file)
+        path = path if path.is_absolute() else root / path
+        return path.read_text(encoding="utf-8")
+    return _option_value(args, "--body") or ""

tradingcodex_cli/commands/subagents.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from tradingcodex_service.application.agents import (
+    AGENT_SPECS,
+    diff_agent_configuration,
+    inspect_agent_configuration,
+    project_agent_configuration,
+    EXPECTED_SUBAGENTS,
+)
+from tradingcodex_service.application.harness import build_subagent_starter_prompt
+from tradingcodex_cli.commands.utils import (
+    _option_value,
+    _parse_agent_list,
+    list_skills,
+    list_subagents,
+    print_json,
+    read_subagent_state,
+    read_thread_policy,
+    skills_for_role,
+)
+
+def subagents(root: Path, argv: list[str]) -> None:
+    sub = argv[0] if argv else "list"
+    args = argv[1:]
+    if sub == "list":
+        for agent in list_subagents(root):
+            print(f"{agent['name']}\t{agent['description']}")
+        return
+    if sub == "prompt":
+        request = " ".join(args).strip()
+        if not request:
+            raise ValueError("Usage: tcx subagents prompt <investment request>")
+        print(build_subagent_starter_prompt(request))
+        return
+    if sub == "status":
+        agents = list_subagents(root)
+        print_json({
+            "expected_count": len(EXPECTED_SUBAGENTS),
+            "installed_count": len(agents),
+            "fixed_roster_ok": len(agents) == len(EXPECTED_SUBAGENTS),
+            "skills_installed": len(list_skills(root)),
+            "thread_policy": read_thread_policy(root),
+            "agents": agents,
+        })
+        return
+    if sub == "state":
+        print_json(read_subagent_state(root, _option_value(args, "--run")))
+        return
+    if sub == "inspect":
+        role = args[0] if args else ""
+        if not role:
+            raise ValueError("Usage: tcx subagents inspect <role>")
+        print_json(inspect_agent_configuration(root, role))
+        return
+    if sub == "diff":
+        role = args[0] if args and not args[0].startswith("--") else _option_value(args, "--role")
+        if not role:
+            raise ValueError("Usage: tcx subagents diff <role>")
+        print_json(diff_agent_configuration(root, role))
+        return
+    if sub == "project":
+        role = _option_value(args, "--role")
+        proposal = _option_value(args, "--proposal")
+        applied_by = _option_value(args, "--applied-by") or "local-cli"
+        result = project_agent_configuration(
+            root,
+            role=role,
+            proposal_path=(Path(proposal) if proposal else None),
+            applied_by=applied_by,
+        )
+        print_json({"status": "projected", "projection_hash": result["projection_hash"], "manifest": ".tradingcodex/generated/projection-manifest.json"})
+        return
+    if sub == "plan":
+        installed = list_subagents(root)
+        requested = [agent["name"] for agent in installed] if "--all" in args else _parse_agent_list(args)
+        if not requested:
+            raise ValueError("Usage: tcx subagents plan <agent...>|--all")
+        installed_names = {agent["name"] for agent in installed}
+        unknown = [agent for agent in requested if agent not in installed_names]
+        thread_policy = read_thread_policy(root)
+        size = max(1, int(thread_policy["max_parallel_subagents"]))
+        batches = [{"batch": i + 1, "agents": requested[i:i + size]} for i in range(0, len(requested), size)]
+        print_json({
+            "requested_count": len(requested),
+            "requested_agents": requested,
+            "all_fixed_roster": "--all" in args,
+            "unknown_agents": unknown,
+            "thread_policy": thread_policy,
+            "parallel_spawn_ok": not unknown and len(batches) == 1,
+            "required_batches": len(batches),
+            "batches": batches,
+            "recommendation": "spawn requested subagents in one batch" if len(batches) == 1 else "spawn each batch sequentially and hand off artifacts before starting the next batch",
+        })
+        if unknown:
+            sys.exit(1)
+        return
+    if sub == "skills":
+        role = args[0] if args else ""
+        if role not in AGENT_SPECS:
+            raise ValueError(f"Unknown subagent or role: {role}")
+        print_json({"agent": role, "skills": skills_for_role(root, role)})
+        return
+    raise ValueError(f"Unknown subagents command: {sub}")

tradingcodex_cli/commands/utils.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from tradingcodex_service.application.agents import (
+    build_projection_state,
+    list_user_visible_skills,
+    project_agent_configuration,
+    skills_for_role as file_native_skills_for_role,
+    write_skill_proposal_file,
+)
+
+def list_subagents(root: Path) -> list[dict[str, str]]:
+    agents = []
+    for path in sorted((root / ".codex" / "agents").glob("*.toml")):
+        text = path.read_text(encoding="utf-8")
+        name = _toml_string(text, "name") or path.stem
+        agents.append({"name": name, "runtime_label": name, "description": _toml_string(text, "description") or ""})
+    return agents
+
+
+def list_skills(root: Path, include_internal: bool = True) -> list[str]:
+    if include_internal:
+        return sorted(build_projection_state(root)["skills"])
+    return list_user_visible_skills(root)
+
+
+def read_thread_policy(root: Path) -> dict[str, Any]:
+    config = _safe_read(root / ".codex" / "config.toml")
+    tc_config = _safe_read(root / ".tradingcodex" / "config.yaml")
+    max_threads = int(_regex(config, r"^max_threads\s*=\s*(\d+)", "1"))
+    max_depth = int(_regex(config, r"^max_depth\s*=\s*(\d+)", "1"))
+    reserved = int(_regex(tc_config, r"^\s*reserved_threads:\s*(\d+)", "0"))
+    return {"max_threads": max_threads, "max_depth": max_depth, "reserved_threads": reserved, "max_parallel_subagents": max(1, max_threads - reserved), "overflow_strategy": _regex(tc_config, r"^\s*overflow_strategy:\s*([A-Za-z0-9_-]+)", "batch_queue")}
+
+
+def read_subagent_state(root: Path, run_id: str | None) -> dict[str, Any]:
+    state = _read_json(root / ".tradingcodex" / "mainagent" / "subagent-session-state.json", {"updated_at": None, "active": {}, "completed": [], "events": []})
+    if not run_id:
+        return {"run_filter": None, **state}
+    return {
+        "run_filter": run_id,
+        "updated_at": state.get("updated_at"),
+        "active": {role: record for role, record in state.get("active", {}).items() if record.get("run_id") == run_id},
+        "completed": [record for record in state.get("completed", []) if record.get("run_id") == run_id],
+        "events": [record for record in state.get("events", []) if record.get("run_id") == run_id],
+    }
+
+
+def skills_for_role(root: Path, role: str) -> list[str]:
+    return file_native_skills_for_role(root, role)
+
+
+def write_skill_proposal(root: Path, type_: str, target: str, skill: str) -> dict[str, Any]:
+    return write_skill_proposal_file(root, type_, target, skill)
+
+
+def apply_skill_proposal(root: Path, proposal_path: Path, approved_by: str | None) -> None:
+    result = project_agent_configuration(root, proposal_path=proposal_path, applied_by=approved_by or "local-cli")
+    print_json({"status": "applied", "proposal_path": proposal_path.relative_to(root).as_posix(), "projection_hash": result["projection_hash"]})
+
+
+def path_check(root: Path, layer: str, name: str, rel: str, codex_native: bool) -> dict[str, Any]:
+    ok = (root / rel).exists()
+    return {"layer": layer, "name": name, "ok": ok, "codexNative": codex_native, "detail": "found" if ok else "missing"}
+
+
+def text_check(root: Path, layer: str, name: str, rel: str, pattern: str, codex_native: bool) -> dict[str, Any]:
+    ok = pattern in _safe_read(root / rel)
+    return {"layer": layer, "name": name, "ok": ok, "codexNative": codex_native, "detail": f"contains {pattern}" if ok else f"missing {pattern}"}
+
+
+def classify_artifact_path(rel: str) -> str:
+    if rel.startswith("trading/research/"):
+        return "evidence_pack"
+    if "order_intent" in rel:
+        return "order_intent"
+    if "approval_receipt" in rel:
+        return "approval_receipt"
+    if rel.startswith("trading/reports/"):
+        return "report"
+    return "artifact"
+
+
+def _option_value(args: list[str], name: str) -> str | None:
+    try:
+        return args[args.index(name) + 1]
+    except Exception:
+        return None
+
+
+def _parse_agent_list(args: list[str]) -> list[str]:
+    return [item.strip() for arg in args for item in arg.split(",") if item.strip()]
+
+
+def _toml_string(text: str, key: str) -> str | None:
+    for line in text.splitlines():
+        if line.startswith(f"{key} = "):
+            return line.split('"')[1]
+    return None
+
+
+def _safe_read(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except Exception:
+        return ""
+
+
+def _read_json(path: Path, default: Any) -> Any:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def _regex(text: str, pattern: str, default: str) -> str:
+    import re
+
+    match = re.search(pattern, text, flags=re.M)
+    return match.group(1) if match else default
+
+
+def _yaml_value(text: str, key: str) -> str | None:
+    for line in text.splitlines():
+        if line.startswith(f"{key}:"):
+            return line.split(":", 1)[1].strip()
+    return None
+
+
+def print_json(value: Any) -> None:
+    print(json.dumps(value, indent=2, ensure_ascii=False, default=str))

tradingcodex_cli/commands/workspaces.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tradingcodex_cli.commands.utils import print_json
+from tradingcodex_service.application.runtime import (
+    ensure_runtime_database,
+    ensure_workspace_manifest,
+    persist_workspace_context_if_available,
+    tradingcodex_db_path,
+)
+
+
+def workspace(root: Path, argv: list[str]) -> None:
+    sub = argv[0] if argv else "status"
+    if sub == "status":
+        manifest = ensure_workspace_manifest(root)
+        ensure_runtime_database(root)
+        context = persist_workspace_context_if_available(root)
+        print_json({
+            "status": "ok",
+            "workspace_name": manifest["project_name"],
+            "workspace_id": manifest["workspace_id"],
+            "active_profile": manifest["active_profile"],
+            "db_path": str(tradingcodex_db_path()),
+            "mcp_scope": manifest["mcp_scope"],
+            "execution_mode": manifest["execution_mode"],
+            "workspace_context": context,
+            "db_canonical": True,
+        })
+        return
+    if sub == "list":
+        ensure_runtime_database(root)
+        from apps.harness.models import WorkspaceContext
+
+        print_json({
+            "db_path": str(tradingcodex_db_path()),
+            "workspaces": [
+                {
+                    "workspace_id": item.workspace_id,
+                    "project_name": item.project_name,
+                    "path": item.path,
+                    "git_remote": item.git_remote,
+                    "git_branch": item.git_branch,
+                    "active_profile": item.active_profile,
+                    "last_seen_at": item.last_seen_at.isoformat(),
+                }
+                for item in WorkspaceContext.objects.all()[:200]
+            ],
+            "db_canonical": True,
+        })
+        return
+    raise ValueError("Usage: tcx workspace status|list")