tlm-cli 0.1.0__tar.gz

tlm_cli-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: tlm-cli
+Version: 0.1.0
+Summary: TLM — AI Tech Lead that enforces TDD, tests, and spec compliance in Claude Code.
+Author-email: TLM <hello@tlm.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://tlm.dev
+Project-URL: Source, https://github.com/tlm-dev/tlm
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# TLM — AI Tech Lead for Claude Code
+
+> The annoying agent that makes Claude do the right thing.
+
+TLM sits inside [Claude Code](https://claude.ai/code) and enforces TDD, tests, and spec compliance — automatically. It interviews you before coding, generates specs, and blocks commits that don't meet your project's quality bar.
+
+## Quick Start
+
+```bash
+pip install tlm-cli
+tlm signup
+cd your-project
+tlm install
+```
+
+That's it. Open Claude Code and start working — TLM activates automatically.
+
+## What Happens
+
+1. **`tlm signup`** — Create your account (one-time)
+2. **`tlm install`** — Scans your project, generates enforcement rules, you approve them interactively. Installs Claude Code hooks.
+3. **Work in Claude Code** — TLM interviews you before features, enforces TDD, checks spec compliance before commits
+4. **`tlm check`** — Manual quality gate (runs your approved checks mechanically)
+
+## How It Works
+
+TLM scans your project and asks Claude to figure out your stack — test framework, linter, deploy targets, coverage thresholds. It generates an enforcement config and presents it for your approval:
+
+```
+TLM Enforcement Config
+
+  Quality Checks (3):
+    ● Tests pass [pre_commit]
+      pytest tests/ -v
+    ● Linting [pre_commit]
+      flake8 src/
+    ○ Security audit [pre_commit]
+      pip-audit
+
+Does this look right?
+  yes — Approve and save
+  [correction] — Tell me what's wrong
+```
+
+You can correct anything conversationally. Once approved, enforcement is mechanical — commands and exit codes, no LLM opinions.
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `tlm signup` | Create account |
+| `tlm auth <key>` | Save API key |
+| `tlm install` | Full setup: scan, approve config, install hooks |
+| `tlm uninstall` | Remove TLM integration (keeps data) |
+| `tlm check` | Run quality gate manually |
+| `tlm status` | Project stats + enforcement status |
+| `tlm learn` | Analyze recent commits for patterns |
+| `tlm learn --all` | Full history analysis |
+
+## Philosophy
+
+1. **Claude knows your stack.** TLM doesn't hardcode detection for any framework. Claude figures it out.
+2. **You approve everything.** Nothing becomes a rule until you say yes.
+3. **Enforcement is mechanical.** Commands and exit codes. No LLM opinions during enforcement.
+4. **Annoying, not a prison.** Every block has an `OVERRIDE`. But you have to be explicit.
+
+## License
+
+MIT

tlm_cli-0.1.0/README.md

@@ -0,0 +1,69 @@
+# TLM — AI Tech Lead for Claude Code
+
+> The annoying agent that makes Claude do the right thing.
+
+TLM sits inside [Claude Code](https://claude.ai/code) and enforces TDD, tests, and spec compliance — automatically. It interviews you before coding, generates specs, and blocks commits that don't meet your project's quality bar.
+
+## Quick Start
+
+```bash
+pip install tlm-cli
+tlm signup
+cd your-project
+tlm install
+```
+
+That's it. Open Claude Code and start working — TLM activates automatically.
+
+## What Happens
+
+1. **`tlm signup`** — Create your account (one-time)
+2. **`tlm install`** — Scans your project, generates enforcement rules, you approve them interactively. Installs Claude Code hooks.
+3. **Work in Claude Code** — TLM interviews you before features, enforces TDD, checks spec compliance before commits
+4. **`tlm check`** — Manual quality gate (runs your approved checks mechanically)
+
+## How It Works
+
+TLM scans your project and asks Claude to figure out your stack — test framework, linter, deploy targets, coverage thresholds. It generates an enforcement config and presents it for your approval:
+
+```
+TLM Enforcement Config
+
+  Quality Checks (3):
+    ● Tests pass [pre_commit]
+      pytest tests/ -v
+    ● Linting [pre_commit]
+      flake8 src/
+    ○ Security audit [pre_commit]
+      pip-audit
+
+Does this look right?
+  yes — Approve and save
+  [correction] — Tell me what's wrong
+```
+
+You can correct anything conversationally. Once approved, enforcement is mechanical — commands and exit codes, no LLM opinions.
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `tlm signup` | Create account |
+| `tlm auth <key>` | Save API key |
+| `tlm install` | Full setup: scan, approve config, install hooks |
+| `tlm uninstall` | Remove TLM integration (keeps data) |
+| `tlm check` | Run quality gate manually |
+| `tlm status` | Project stats + enforcement status |
+| `tlm learn` | Analyze recent commits for patterns |
+| `tlm learn --all` | Full history analysis |
+
+## Philosophy
+
+1. **Claude knows your stack.** TLM doesn't hardcode detection for any framework. Claude figures it out.
+2. **You approve everything.** Nothing becomes a rule until you say yes.
+3. **Enforcement is mechanical.** Commands and exit codes. No LLM opinions during enforcement.
+4. **Annoying, not a prison.** Every block has an `OVERRIDE`. But you have to be explicit.
+
+## License
+
+MIT

tlm_cli-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tlm-cli"
+version = "0.1.0"
+description = "TLM — AI Tech Lead that enforces TDD, tests, and spec compliance in Claude Code."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    {name = "TLM", email = "hello@tlm.dev"},
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Quality Assurance",
+    "Intended Audience :: Developers",
+]
+dependencies = [
+    "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://tlm.dev"
+Source = "https://github.com/tlm-dev/tlm"
+
+[project.scripts]
+tlm = "tlm.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[tool.setuptools.packages.find]
+include = ["tlm*"]

tlm_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tlm_cli-0.1.0/tests/test_api_client.py

@@ -0,0 +1,407 @@
+"""
+Tests for TLM API Client — HTTP client for TLM server.
+
+Uses unittest.mock to mock httpx calls. Tests all endpoint methods,
+auth header injection, error handling, timeout behavior, and credential management.
+"""
+
+import json
+import os
+from pathlib import Path
+from unittest.mock import patch, MagicMock, PropertyMock
+
+import pytest
+
+from tlm.api_client import (
+    TLMClient,
+    TLMAuthError,
+    TLMServerError,
+    TLMConnectionError,
+    load_credentials,
+    save_credentials,
+    get_client,
+)
+
+
+# ─── Fixtures ─────────────────────────────────────────────────
+
+@pytest.fixture
+def credentials_dir(tmp_path):
+    """Temporary directory for credentials."""
+    cred_dir = tmp_path / ".tlm"
+    cred_dir.mkdir()
+    return cred_dir
+
+
+@pytest.fixture
+def mock_response():
+    """Create a mock httpx response."""
+    def _make(status_code=200, json_data=None, text=""):
+        resp = MagicMock()
+        resp.status_code = status_code
+        resp.json.return_value = json_data or {}
+        resp.text = text or json.dumps(json_data or {})
+        resp.is_success = 200 <= status_code < 300
+        resp.raise_for_status = MagicMock()
+        if status_code >= 400:
+            import httpx
+            resp.raise_for_status.side_effect = httpx.HTTPStatusError(
+                "error", request=MagicMock(), response=resp
+            )
+        return resp
+    return _make
+
+
+@pytest.fixture
+def client():
+    """Create a TLMClient with test credentials."""
+    return TLMClient(api_key="tlm_sk_test123", base_url="https://api.test.tlm.dev")
+
+
+# ─── Credential Management Tests ─────────────────────────────
+
+class TestCredentials:
+    def test_save_credentials(self, credentials_dir):
+        cred_file = credentials_dir / "credentials.json"
+        save_credentials("tlm_sk_abc123", credentials_dir=str(credentials_dir))
+        assert cred_file.exists()
+        data = json.loads(cred_file.read_text())
+        assert data["api_key"] == "tlm_sk_abc123"
+
+    def test_load_credentials(self, credentials_dir):
+        cred_file = credentials_dir / "credentials.json"
+        cred_file.write_text(json.dumps({"api_key": "tlm_sk_loaded"}))
+        key = load_credentials(credentials_dir=str(credentials_dir))
+        assert key == "tlm_sk_loaded"
+
+    def test_load_credentials_missing_file(self, credentials_dir):
+        key = load_credentials(credentials_dir=str(credentials_dir))
+        assert key is None
+
+    def test_load_credentials_corrupted(self, credentials_dir):
+        cred_file = credentials_dir / "credentials.json"
+        cred_file.write_text("not json")
+        key = load_credentials(credentials_dir=str(credentials_dir))
+        assert key is None
+
+    def test_save_credentials_creates_dir(self, tmp_path):
+        cred_dir = tmp_path / "nonexistent" / ".tlm"
+        save_credentials("tlm_sk_new", credentials_dir=str(cred_dir))
+        assert (cred_dir / "credentials.json").exists()
+
+    def test_save_overwrite(self, credentials_dir):
+        save_credentials("tlm_sk_first", credentials_dir=str(credentials_dir))
+        save_credentials("tlm_sk_second", credentials_dir=str(credentials_dir))
+        key = load_credentials(credentials_dir=str(credentials_dir))
+        assert key == "tlm_sk_second"
+
+    def test_save_preserves_other_fields(self, credentials_dir):
+        cred_file = credentials_dir / "credentials.json"
+        cred_file.write_text(json.dumps({"api_key": "old", "base_url": "https://custom.url"}))
+        save_credentials("tlm_sk_new", credentials_dir=str(credentials_dir))
+        data = json.loads(cred_file.read_text())
+        assert data["api_key"] == "tlm_sk_new"
+        assert data["base_url"] == "https://custom.url"
+
+
+# ─── Client Construction Tests ────────────────────────────────
+
+class TestClientConstruction:
+    def test_creates_with_api_key(self):
+        client = TLMClient(api_key="tlm_sk_test")
+        assert client.api_key == "tlm_sk_test"
+
+    def test_default_base_url(self):
+        from tlm.api_client import DEFAULT_BASE_URL
+        client = TLMClient(api_key="tlm_sk_test")
+        assert client.base_url == DEFAULT_BASE_URL
+
+    def test_custom_base_url(self):
+        client = TLMClient(api_key="tlm_sk_test", base_url="https://custom.api.com")
+        assert client.base_url == "https://custom.api.com"
+
+    def test_get_client_with_saved_credentials(self, credentials_dir):
+        save_credentials("tlm_sk_saved", credentials_dir=str(credentials_dir))
+        client = get_client(credentials_dir=str(credentials_dir))
+        assert client is not None
+        assert client.api_key == "tlm_sk_saved"
+
+    def test_get_client_no_credentials(self, credentials_dir):
+        client = get_client(credentials_dir=str(credentials_dir))
+        assert client is None
+
+
+# ─── Auth Header Tests ────────────────────────────────────────
+
+class TestAuthHeaders:
+    def test_auth_header_included(self, client):
+        headers = client._headers()
+        assert "Authorization" in headers
+        assert headers["Authorization"] == "Bearer tlm_sk_test123"
+
+    def test_content_type_json(self, client):
+        headers = client._headers()
+        assert headers.get("Content-Type") == "application/json"
+
+
+# ─── Auth Endpoint Tests ─────────────────────────────────────
+
+class TestAuthEndpoints:
+    @patch("tlm.api_client.httpx")
+    def test_signup(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "api_key": "tlm_sk_new",
+            "user_id": "usr_123",
+            "email": "test@example.com",
+        })
+        result = client.signup("test@example.com", "password123")
+        assert result["api_key"] == "tlm_sk_new"
+        mock_httpx.post.assert_called_once()
+
+    @patch("tlm.api_client.httpx")
+    def test_login(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "api_key": "tlm_sk_existing",
+            "user_id": "usr_456",
+        })
+        result = client.login("test@example.com", "password123")
+        assert result["api_key"] == "tlm_sk_existing"
+
+    @patch("tlm.api_client.httpx")
+    def test_me(self, mock_httpx, client, mock_response):
+        mock_httpx.get.return_value = mock_response(200, {
+            "user_id": "usr_123",
+            "email": "test@example.com",
+            "tier": "free",
+        })
+        result = client.me()
+        assert result["email"] == "test@example.com"
+
+    @patch("tlm.api_client.httpx")
+    def test_auth_error_on_401(self, mock_httpx, client, mock_response):
+        mock_httpx.get.return_value = mock_response(401, {"detail": "Invalid API key"})
+        with pytest.raises(TLMAuthError):
+            client.me()
+
+
+# ─── Project Endpoint Tests ──────────────────────────────────
+
+class TestProjectEndpoints:
+    @patch("tlm.api_client.httpx")
+    def test_create_project(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "project_id": "proj_123",
+            "name": "my-app",
+            "fingerprint": "abc123",
+        })
+        result = client.create_project("my-app", "abc123")
+        assert result["project_id"] == "proj_123"
+
+    @patch("tlm.api_client.httpx")
+    def test_list_projects(self, mock_httpx, client, mock_response):
+        mock_httpx.get.return_value = mock_response(200, {
+            "projects": [
+                {"project_id": "proj_1", "name": "app1"},
+                {"project_id": "proj_2", "name": "app2"},
+            ]
+        })
+        result = client.list_projects()
+        assert len(result["projects"]) == 2
+
+    @patch("tlm.api_client.httpx")
+    def test_delete_project(self, mock_httpx, client, mock_response):
+        mock_httpx.delete.return_value = mock_response(200, {"deleted": True})
+        result = client.delete_project("proj_123")
+        assert result["deleted"] is True
+
+
+# ─── Intelligence Endpoint Tests ─────────────────────────────
+
+class TestIntelligenceEndpoints:
+    @patch("tlm.api_client.httpx")
+    def test_scan(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "profile": "## Stack\nPython, FastAPI",
+        })
+        result = client.scan("proj_123", "file_tree_here", "samples_here")
+        assert "profile" in result
+
+    @patch("tlm.api_client.httpx")
+    def test_generate_config(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "config": {"checks": [], "environments": {}},
+        })
+        result = client.generate_config("proj_123", "profile", "tree", "samples")
+        assert "config" in result
+
+    @patch("tlm.api_client.httpx")
+    def test_update_config(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "config": {"checks": [{"name": "test"}]},
+        })
+        result = client.update_config("proj_123", {"checks": []}, "add tests", "profile")
+        assert "config" in result
+
+    @patch("tlm.api_client.httpx")
+    def test_approve_config(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {"approved": True})
+        result = client.approve_config("proj_123", {"checks": []})
+        assert result["approved"] is True
+
+    @patch("tlm.api_client.httpx")
+    def test_check_drift(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "stale": False,
+            "drifted": False,
+        })
+        result = client.check_drift("proj_123", {"checks": []}, {"file": "hash"}, {})
+        assert result["stale"] is False
+
+    @patch("tlm.api_client.httpx")
+    def test_compliance_check(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "review": "### Verdict: PASS",
+        })
+        result = client.compliance_check("proj_123", "spec content", "diff content", "profile", "config")
+        assert "review" in result
+
+
+# ─── Discovery Endpoint Tests ────────────────────────────────
+
+class TestDiscoveryEndpoints:
+    @patch("tlm.api_client.httpx")
+    def test_discovery_start(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "session_id": "disc_123",
+            "response": "Tell me about this feature...",
+        })
+        result = client.discovery_start("proj_123", "Add payments")
+        assert result["session_id"] == "disc_123"
+        assert "response" in result
+
+    @patch("tlm.api_client.httpx")
+    def test_discovery_respond(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "response": "Great, and what about error handling?",
+            "is_complete": False,
+        })
+        result = client.discovery_respond("proj_123", "disc_123", "Use Stripe for processing")
+        assert "response" in result
+
+    @patch("tlm.api_client.httpx")
+    def test_discovery_generate(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "spec": "# Payment Feature Spec",
+            "instructions": "# TLM Engineering Rules",
+            "knowledge": "New payment domain knowledge",
+        })
+        result = client.discovery_generate("proj_123", "disc_123")
+        assert "spec" in result
+        assert "instructions" in result
+
+
+# ─── Learning Endpoint Tests ─────────────────────────────────
+
+class TestLearningEndpoints:
+    @patch("tlm.api_client.httpx")
+    def test_analyze_commit(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "analysis": {
+                "hash": "abc123",
+                "category": "bug_fix",
+                "planned": False,
+            },
+        })
+        commit = {"hash": "abc123", "message": "fix bug", "author": "dev",
+                  "date": "2026-02-15", "diff": "diff content"}
+        result = client.analyze_commit("proj_123", commit)
+        assert result["analysis"]["category"] == "bug_fix"
+
+    @patch("tlm.api_client.httpx")
+    def test_synthesize(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(200, {
+            "synthesis": {
+                "total_commits": 5,
+                "spec_accuracy_percent": 80,
+                "interview_improvements": ["Ask about edge cases"],
+            },
+        })
+        result = client.synthesize("proj_123", [{"hash": "a"}])
+        assert result["synthesis"]["total_commits"] == 5
+
+    @patch("tlm.api_client.httpx")
+    def test_learning_status(self, mock_httpx, client, mock_response):
+        mock_httpx.get.return_value = mock_response(200, {
+            "unprocessed_count": 3,
+            "latest_synthesis": None,
+        })
+        result = client.learning_status("proj_123")
+        assert result["unprocessed_count"] == 3
+
+
+# ─── Sync Endpoint Tests ─────────────────────────────────────
+
+class TestSyncEndpoint:
+    @patch("tlm.api_client.httpx")
+    def test_sync(self, mock_httpx, client, mock_response):
+        mock_httpx.get.return_value = mock_response(200, {
+            "knowledge": "# Knowledge Base\n- Uses PostgreSQL",
+            "profile": "## Stack\nPython",
+            "enforcement_config": {"checks": []},
+            "latest_synthesis": None,
+            "specs": [],
+            "project_lessons": "",
+        })
+        result = client.sync("proj_123")
+        assert "knowledge" in result
+        assert "profile" in result
+        assert "enforcement_config" in result
+
+    @patch("tlm.api_client.httpx")
+    def test_sync_timeout(self, mock_httpx, client):
+        import httpx
+        mock_httpx.get.side_effect = httpx.TimeoutException("timeout")
+        with pytest.raises(TLMConnectionError):
+            client.sync("proj_123", timeout=3.0)
+
+
+# ─── Error Handling Tests ─────────────────────────────────────
+
+class TestErrorHandling:
+    @patch("tlm.api_client.httpx")
+    def test_401_raises_auth_error(self, mock_httpx, client, mock_response):
+        mock_httpx.get.return_value = mock_response(401, {"detail": "Unauthorized"})
+        with pytest.raises(TLMAuthError):
+            client.me()
+
+    @patch("tlm.api_client.httpx")
+    def test_500_raises_server_error(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(500, {"detail": "Internal error"})
+        with pytest.raises(TLMServerError):
+            client.scan("proj_123", "tree", "samples")
+
+    @patch("tlm.api_client.httpx")
+    def test_connection_error(self, mock_httpx, client):
+        import httpx
+        mock_httpx.post.side_effect = httpx.ConnectError("Connection refused")
+        with pytest.raises(TLMConnectionError):
+            client.scan("proj_123", "tree", "samples")
+
+    @patch("tlm.api_client.httpx")
+    def test_timeout_error(self, mock_httpx, client):
+        import httpx
+        mock_httpx.post.side_effect = httpx.TimeoutException("timeout")
+        with pytest.raises(TLMConnectionError):
+            client.scan("proj_123", "tree", "samples")
+
+    @patch("tlm.api_client.httpx")
+    def test_403_raises_auth_error(self, mock_httpx, client, mock_response):
+        mock_httpx.get.return_value = mock_response(403, {"detail": "Forbidden"})
+        with pytest.raises(TLMAuthError):
+            client.me()
+
+    @patch("tlm.api_client.httpx")
+    def test_422_raises_server_error(self, mock_httpx, client, mock_response):
+        mock_httpx.post.return_value = mock_response(422, {"detail": "Validation error"})
+        with pytest.raises(TLMServerError):
+            client.create_project("bad", "data")