cicd-aiops 0.1.0__tar.gz

cicd_aiops-0.1.0/.github/workflows/mcp-publish.yml

@@ -0,0 +1,55 @@
+name: mcp-publish
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish-mcp:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Wait for PyPI
+        # The release event also triggers the PyPI publish workflow; the MCP
+        # registry validates that the package version exists on PyPI, so poll
+        # until it has propagated (every 15s, up to 10 minutes).
+        run: |
+          python3 - <<'EOF'
+          import json
+          import sys
+          import time
+          import urllib.error
+          import urllib.request
+
+          with open("server.json", encoding="utf-8") as f:
+              package = json.load(f)["packages"][0]
+          name, version = package["identifier"], package["version"]
+          url = f"https://pypi.org/pypi/{name}/{version}/json"
+          deadline = time.monotonic() + 600
+          while True:
+              try:
+                  with urllib.request.urlopen(url, timeout=10):
+                      print(f"{name}=={version} is available on PyPI.")
+                      sys.exit(0)
+              except (urllib.error.URLError, OSError) as exc:
+                  print(f"{name}=={version} not on PyPI yet ({exc}); "
+                        "retrying in 15s...")
+              if time.monotonic() >= deadline:
+                  sys.exit(f"Timed out after 10 minutes waiting for "
+                           f"{name}=={version} to appear on PyPI. "
+                           "Check the PyPI publish workflow, then re-run "
+                           "this workflow via workflow_dispatch.")
+              time.sleep(15)
+          EOF
+      - name: Install mcp-publisher
+        run: |
+          curl -sL "https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher
+      - name: Login to MCP Registry (GitHub OIDC)
+        run: ./mcp-publisher login github-oidc
+      - name: Publish server.json
+        run: ./mcp-publisher publish

cicd_aiops-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish to PyPI
+
+# Trusted Publishing (OIDC) — publishes from GitHub's runners with no API token,
+# sidestepping the local-IP / account new-project rate limit. Configure a matching
+# "trusted publisher" for this package on PyPI (see the repo release notes).
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write   # required for PyPI Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v5
+      - name: Build sdist + wheel
+        run: uv build
+      - name: Publish to PyPI (Trusted Publishing)
+        uses: pypa/gh-action-pypi-publish@release/v1

cicd_aiops-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+dist/
+__pycache__/
+*.pyc
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+.coverage

cicd_aiops-0.1.0/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+## v0.1.0 — 2026-07-17
+
+Initial preview release.
+
+- **Platforms**: self-managed GitLab (REST API v4, `PRIVATE-TOKEN`) and
+  self-hosted Gitea (API v1, `Authorization: token`) behind a name-keyed
+  platform registry; unsupported surfaces raise teaching errors.
+- **Reads (16)**: server version + token identity + overview; projects with
+  storage statistics; pipelines/runs, jobs, trace tails; runner fleet
+  (GitLab); merge/pull requests, branches, protection rules, releases;
+  artifact inventories with expiry.
+- **Flagship analyses (4)**: `pipeline_failure_rca` (test-failure /
+  dependency-network / runner-timeout / oom / script-error with evidence),
+  `runner_health_rca` (offline/stale/paused, queue waits, tag saturation),
+  `artifact_storage_bloat_analysis` (ranked storage + reclaimable bytes),
+  `stale_work_audit` (idle MRs/branches, protection gaps).
+- **Governed writes (6)**: `retry_pipeline` / `cancel_pipeline` (priorState
+  status), `pause_runner` / `resume_runner` (reversible undo pair),
+  `delete_artifacts` (risk=high, priorState bytes/count, irreversible),
+  `update_branch_protection` (undo replays prior settings). All with
+  `dry_run` previews; CLI writes double-confirm and run through the governed
+  path (audited).
+- **Governance harness** bundled: audit (`~/.cicd-aiops/audit.db`), policy
+  engine with secure-by-default dual-control for high risk, token/runaway
+  budgets, undo store, injection-safe output sanitisation.
+- **Secrets**: encrypted store (`secrets.enc`, Fernet + scrypt), `init`
+  wizard, `secret` commands; TLS verification defaults ON.
+- 114 tests, mock-only (no live server validation yet).

cicd_aiops-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wei <zhouwei008@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cicd_aiops-0.1.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: cicd-aiops
+Version: 0.1.0
+Summary: Governed AI-ops for self-managed GitLab + Gitea CI/CD: pipelines, jobs, runners, artifacts, repo hygiene, flagship RCA analyses (pipeline failures, runner health, storage bloat, stale work), and governed writes (retry/cancel, pause/resume, artifact deletion, branch protection) with a built-in governance harness (audit, budget, undo, risk tiers)
+Author-email: wei <zhouwei008@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: cryptography>=42.0
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: mcp[cli]<2.0,>=1.10
+Requires-Dist: pyyaml<7.0,>=6.0
+Requires-Dist: rich<16.0,>=13.0
+Requires-Dist: typer<1.0,>=0.12
+Description-Content-Type: text/markdown
+
+# CICD AIops
+
+**Governed AI-ops for self-managed GitLab and self-hosted Gitea.**
+
+`cicd-aiops` is for the team running its *own* CI/CD forge — a GitLab instance
+or a Gitea server on your hardware, in your lab, behind your VPN — who want an
+AI agent that can answer "why did the pipeline fail?", "which runner is
+wedged?", "where did 40 GB of artifact storage go?" and "what work went
+stale?" and then act (retry, cancel, pause, delete, protect) **only** through
+an audited, budgeted, risk-tiered, undo-recorded governance harness. It is not
+a SaaS integration: it speaks the GitLab REST API v4 and the Gitea API v1
+directly against your server, with credentials encrypted at rest.
+
+> **Preview / mock-only**: modelled from each project's public API docs and
+> exercised against mocked HTTP responses; not yet validated against live
+> servers. `cicd-aiops doctor` is the fastest live check.
+
+> **Routing**: Do NOT use this for Kubernetes deploy state — use k8s-aiops.
+> This tool ends at the CI/CD server's API (pipelines, runners, artifacts,
+> repo hygiene).
+
+## Quick start
+
+```bash
+uv tool install cicd-aiops        # or: pip install cicd-aiops
+
+cicd-aiops init        # wizard: base URL + token (encrypted) + TLS verify
+cicd-aiops doctor      # connectivity + token-scope probe per target
+cicd-aiops overview    # version, identity, projects, runners at a glance
+```
+
+Then the interesting parts:
+
+```bash
+cicd-aiops rca pipelines dev/api        # classify recent failed pipelines
+cicd-aiops rca runners                  # offline/stale runners, tag saturation
+cicd-aiops rca storage                  # artifact/repo bloat, reclaimable bytes
+cicd-aiops rca stale dev/api            # stale MRs/branches, protection gaps
+
+cicd-aiops pipelines retry dev/api 42 --dry-run
+cicd-aiops artifacts delete dev/api --older-than-days 30 --dry-run
+```
+
+Every write has `--dry-run` and a double confirmation, and executes through
+the same governed path the MCP tools use — so CLI writes are audited too.
+
+## Support scope
+
+| Surface | GitLab (REST v4, self-managed) | Gitea (API v1, self-hosted) |
+|---|---|---|
+| Server version + token identity | ✅ | ✅ |
+| Projects + storage statistics | ✅ (`statistics=true`) | ✅ (repo `size`) |
+| Pipelines / runs, jobs, trace tails | ✅ | ✅ (Actions runs/jobs/logs) |
+| Runner fleet (list/detail) | ✅ | ❌ teaching error (no API v1 equivalent) |
+| Merge/pull requests, branches, protection, releases | ✅ | ✅ |
+| Artifact inventory | ✅ (via jobs) | ✅ (Actions artifacts) |
+| `retry_pipeline` / `cancel_pipeline` | ✅ | ❌ teaching error |
+| `pause_runner` / `resume_runner` | ✅ | ❌ teaching error |
+| `delete_artifacts` | ✅ | ❌ teaching error |
+| `update_branch_protection` | ✅ | ✅ |
+
+Where a platform lacks a surface, the platform registry raises a *teaching
+error* naming the resources that **are** available — the agent learns instead
+of hitting a mystery 404. GitLab.com / Gitea Cloud SaaS accounts are out of
+scope by design: this tool targets self-managed instances.
+
+## Flagship analyses (the reason this tool exists)
+
+1. **`pipeline_failure_rca`** — pulls recent failed pipelines with failed-job
+   trace tails and classifies each failure: *test-failure /
+   dependency-network / runner-timeout / oom / script-error*, with the matched
+   evidence, a cause, and an action per pipeline.
+2. **`runner_health_rca`** — offline/stale/paused runners (contact-age
+   threshold), jobs queued past a threshold, and per-tag saturation (queued
+   jobs vs online runners).
+3. **`artifact_storage_bloat_analysis`** — projects ranked by repo + artifact
+   bytes, expired-but-kept artifacts, and a reclaimable-bytes estimate that
+   feeds straight into `delete_artifacts --dry-run`.
+4. **`stale_work_audit`** — merge/pull requests idle past N days, branches
+   with no commits for N days, and protection gaps (unprotected default
+   branch, force-push allowed).
+
+All four are transparent heuristics: thresholds are named parameters and every
+flag carries its numbers.
+
+## Governance (built in, always on)
+
+Every MCP tool and every CLI write runs through the vendored harness in
+`cicd_aiops/governance/`:
+
+- **Audit** — every call (including denials and errors) lands in
+  `~/.cicd-aiops/audit.db` with params, status, risk level, and approver.
+- **Budget** — call/time budgets and a runaway breaker
+  (`CICD_MAX_TOOL_CALLS`, `CICD_MAX_TOOL_SECONDS`, `CICD_RUNAWAY_MAX`).
+- **Risk tiers, secure by default** — reads are `low`; mutating writes are
+  `medium`; `delete_artifacts` is `high`. With no `rules.yaml`, high-risk
+  writes are **denied unless a named approver** is set
+  (`CICD_AUDIT_APPROVED_BY`, plus `CICD_AUDIT_RATIONALE`). `init` seeds a
+  starter `rules.yaml` with that dual-control tier spelled out.
+- **Undo** — reversible writes record a replayable inverse in
+  `~/.cicd-aiops/undo.db`, built from the *fetched* before-state:
+  `pause_runner` ⇄ `resume_runner`, and `update_branch_protection` replays the
+  prior settings. Irreversible writes (`retry_pipeline`, `cancel_pipeline`,
+  `delete_artifacts`) record `priorState` (status / bytes+count) instead.
+- **Dry-run everywhere** — every write takes `dry_run=True` (MCP) /
+  `--dry-run` (CLI) and previews without calling the server.
+- **Sanitize** — all server-returned text is folded through an
+  injection-safe normaliser (bounded strings, capped depth) before an agent
+  sees it; all path parameters are percent-encoded so an identifier can never
+  rewrite a URL.
+
+### Secrets
+
+Tokens live in `~/.cicd-aiops/secrets.enc` — Fernet-encrypted, key derived
+from a master password via scrypt. Never plaintext on disk. Set
+`CICD_AIOPS_MASTER_PASSWORD` for non-interactive/MCP use, and manage with
+`cicd-aiops secret set|list|remove|migrate`. TLS verification defaults ON
+(the init wizard asks before turning it off for lab certs).
+
+## MCP server
+
+26 governed tools (20 reads incl. the four flagship analyses, 6 writes).
+
+```json
+{
+  "mcpServers": {
+    "cicd-aiops": {
+      "command": "uvx",
+      "args": ["--from", "cicd-aiops", "cicd-aiops-mcp"],
+      "env": {
+        "CICD_AIOPS_MASTER_PASSWORD": "your-master-password"
+      }
+    }
+  }
+}
+```
+
+> **Env-block caveat**: MCP clients launch the server with a *minimal*
+> environment — your shell profile is not sourced. Anything the server needs
+> (`CICD_AIOPS_MASTER_PASSWORD`, `CICD_AIOPS_HOME`, `CICD_AUDIT_APPROVED_BY`
+> for high-risk writes) must be set in the `env` block above, not in
+> `~/.zshrc`.
+
+Alternatively: `cicd-aiops mcp` (same server, CLI entry point).
+
+## Configuration
+
+`~/.cicd-aiops/config.yaml` (the wizard writes this):
+
+```yaml
+targets:
+  - name: gl1
+    platform: gitlab            # or: gitea
+    base_url: https://git.example.com
+    verify_ssl: true            # default ON; set false only for lab certs
+```
+
+The token for each target is stored encrypted under the target's name.
+Relocate all state (config, audit, undo, secrets) with `CICD_AIOPS_HOME`.
+
+## Development
+
+```bash
+uv sync
+uv run pytest -q
+uv run ruff check .
+```
+
+## 缺功能？
+
+缺功能提 issue/PR 欢迎留言 — if a GitLab/Gitea surface you need is missing
+(runner administration on newer Gitea, per-job retry, scheduled pipelines,
+group-level rollups…), open an issue or PR at
+https://github.com/AIops-tools/CICD-AIops. The platform registry is designed
+so a new resource is one path-map entry, not a refactor.
+
+## License
+
+MIT. GitLab is a trademark of GitLab Inc.; Gitea is a trademark of its
+project owners. This project is independent and not affiliated with either.

cicd_aiops-0.1.0/README.md

@@ -0,0 +1,180 @@
+# CICD AIops
+
+**Governed AI-ops for self-managed GitLab and self-hosted Gitea.**
+
+`cicd-aiops` is for the team running its *own* CI/CD forge — a GitLab instance
+or a Gitea server on your hardware, in your lab, behind your VPN — who want an
+AI agent that can answer "why did the pipeline fail?", "which runner is
+wedged?", "where did 40 GB of artifact storage go?" and "what work went
+stale?" and then act (retry, cancel, pause, delete, protect) **only** through
+an audited, budgeted, risk-tiered, undo-recorded governance harness. It is not
+a SaaS integration: it speaks the GitLab REST API v4 and the Gitea API v1
+directly against your server, with credentials encrypted at rest.
+
+> **Preview / mock-only**: modelled from each project's public API docs and
+> exercised against mocked HTTP responses; not yet validated against live
+> servers. `cicd-aiops doctor` is the fastest live check.
+
+> **Routing**: Do NOT use this for Kubernetes deploy state — use k8s-aiops.
+> This tool ends at the CI/CD server's API (pipelines, runners, artifacts,
+> repo hygiene).
+
+## Quick start
+
+```bash
+uv tool install cicd-aiops        # or: pip install cicd-aiops
+
+cicd-aiops init        # wizard: base URL + token (encrypted) + TLS verify
+cicd-aiops doctor      # connectivity + token-scope probe per target
+cicd-aiops overview    # version, identity, projects, runners at a glance
+```
+
+Then the interesting parts:
+
+```bash
+cicd-aiops rca pipelines dev/api        # classify recent failed pipelines
+cicd-aiops rca runners                  # offline/stale runners, tag saturation
+cicd-aiops rca storage                  # artifact/repo bloat, reclaimable bytes
+cicd-aiops rca stale dev/api            # stale MRs/branches, protection gaps
+
+cicd-aiops pipelines retry dev/api 42 --dry-run
+cicd-aiops artifacts delete dev/api --older-than-days 30 --dry-run
+```
+
+Every write has `--dry-run` and a double confirmation, and executes through
+the same governed path the MCP tools use — so CLI writes are audited too.
+
+## Support scope
+
+| Surface | GitLab (REST v4, self-managed) | Gitea (API v1, self-hosted) |
+|---|---|---|
+| Server version + token identity | ✅ | ✅ |
+| Projects + storage statistics | ✅ (`statistics=true`) | ✅ (repo `size`) |
+| Pipelines / runs, jobs, trace tails | ✅ | ✅ (Actions runs/jobs/logs) |
+| Runner fleet (list/detail) | ✅ | ❌ teaching error (no API v1 equivalent) |
+| Merge/pull requests, branches, protection, releases | ✅ | ✅ |
+| Artifact inventory | ✅ (via jobs) | ✅ (Actions artifacts) |
+| `retry_pipeline` / `cancel_pipeline` | ✅ | ❌ teaching error |
+| `pause_runner` / `resume_runner` | ✅ | ❌ teaching error |
+| `delete_artifacts` | ✅ | ❌ teaching error |
+| `update_branch_protection` | ✅ | ✅ |
+
+Where a platform lacks a surface, the platform registry raises a *teaching
+error* naming the resources that **are** available — the agent learns instead
+of hitting a mystery 404. GitLab.com / Gitea Cloud SaaS accounts are out of
+scope by design: this tool targets self-managed instances.
+
+## Flagship analyses (the reason this tool exists)
+
+1. **`pipeline_failure_rca`** — pulls recent failed pipelines with failed-job
+   trace tails and classifies each failure: *test-failure /
+   dependency-network / runner-timeout / oom / script-error*, with the matched
+   evidence, a cause, and an action per pipeline.
+2. **`runner_health_rca`** — offline/stale/paused runners (contact-age
+   threshold), jobs queued past a threshold, and per-tag saturation (queued
+   jobs vs online runners).
+3. **`artifact_storage_bloat_analysis`** — projects ranked by repo + artifact
+   bytes, expired-but-kept artifacts, and a reclaimable-bytes estimate that
+   feeds straight into `delete_artifacts --dry-run`.
+4. **`stale_work_audit`** — merge/pull requests idle past N days, branches
+   with no commits for N days, and protection gaps (unprotected default
+   branch, force-push allowed).
+
+All four are transparent heuristics: thresholds are named parameters and every
+flag carries its numbers.
+
+## Governance (built in, always on)
+
+Every MCP tool and every CLI write runs through the vendored harness in
+`cicd_aiops/governance/`:
+
+- **Audit** — every call (including denials and errors) lands in
+  `~/.cicd-aiops/audit.db` with params, status, risk level, and approver.
+- **Budget** — call/time budgets and a runaway breaker
+  (`CICD_MAX_TOOL_CALLS`, `CICD_MAX_TOOL_SECONDS`, `CICD_RUNAWAY_MAX`).
+- **Risk tiers, secure by default** — reads are `low`; mutating writes are
+  `medium`; `delete_artifacts` is `high`. With no `rules.yaml`, high-risk
+  writes are **denied unless a named approver** is set
+  (`CICD_AUDIT_APPROVED_BY`, plus `CICD_AUDIT_RATIONALE`). `init` seeds a
+  starter `rules.yaml` with that dual-control tier spelled out.
+- **Undo** — reversible writes record a replayable inverse in
+  `~/.cicd-aiops/undo.db`, built from the *fetched* before-state:
+  `pause_runner` ⇄ `resume_runner`, and `update_branch_protection` replays the
+  prior settings. Irreversible writes (`retry_pipeline`, `cancel_pipeline`,
+  `delete_artifacts`) record `priorState` (status / bytes+count) instead.
+- **Dry-run everywhere** — every write takes `dry_run=True` (MCP) /
+  `--dry-run` (CLI) and previews without calling the server.
+- **Sanitize** — all server-returned text is folded through an
+  injection-safe normaliser (bounded strings, capped depth) before an agent
+  sees it; all path parameters are percent-encoded so an identifier can never
+  rewrite a URL.
+
+### Secrets
+
+Tokens live in `~/.cicd-aiops/secrets.enc` — Fernet-encrypted, key derived
+from a master password via scrypt. Never plaintext on disk. Set
+`CICD_AIOPS_MASTER_PASSWORD` for non-interactive/MCP use, and manage with
+`cicd-aiops secret set|list|remove|migrate`. TLS verification defaults ON
+(the init wizard asks before turning it off for lab certs).
+
+## MCP server
+
+26 governed tools (20 reads incl. the four flagship analyses, 6 writes).
+
+```json
+{
+  "mcpServers": {
+    "cicd-aiops": {
+      "command": "uvx",
+      "args": ["--from", "cicd-aiops", "cicd-aiops-mcp"],
+      "env": {
+        "CICD_AIOPS_MASTER_PASSWORD": "your-master-password"
+      }
+    }
+  }
+}
+```
+
+> **Env-block caveat**: MCP clients launch the server with a *minimal*
+> environment — your shell profile is not sourced. Anything the server needs
+> (`CICD_AIOPS_MASTER_PASSWORD`, `CICD_AIOPS_HOME`, `CICD_AUDIT_APPROVED_BY`
+> for high-risk writes) must be set in the `env` block above, not in
+> `~/.zshrc`.
+
+Alternatively: `cicd-aiops mcp` (same server, CLI entry point).
+
+## Configuration
+
+`~/.cicd-aiops/config.yaml` (the wizard writes this):
+
+```yaml
+targets:
+  - name: gl1
+    platform: gitlab            # or: gitea
+    base_url: https://git.example.com
+    verify_ssl: true            # default ON; set false only for lab certs
+```
+
+The token for each target is stored encrypted under the target's name.
+Relocate all state (config, audit, undo, secrets) with `CICD_AIOPS_HOME`.
+
+## Development
+
+```bash
+uv sync
+uv run pytest -q
+uv run ruff check .
+```
+
+## 缺功能？
+
+缺功能提 issue/PR 欢迎留言 — if a GitLab/Gitea surface you need is missing
+(runner administration on newer Gitea, per-job retry, scheduled pipelines,
+group-level rollups…), open an issue or PR at
+https://github.com/AIops-tools/CICD-AIops. The platform registry is designed
+so a new resource is one path-map entry, not a refactor.
+
+## License
+
+MIT. GitLab is a trademark of GitLab Inc.; Gitea is a trademark of its
+project owners. This project is independent and not affiliated with either.

cicd_aiops-0.1.0/RELEASE_NOTES.md

@@ -0,0 +1,34 @@
+# cicd-aiops v0.1.0 — release notes
+
+First preview of **cicd-aiops**: governed AI-ops for self-managed GitLab and
+self-hosted Gitea CI/CD servers.
+
+## Highlights
+
+- **26 governed MCP tools** (20 reads incl. 4 flagship RCAs, 6 writes), every
+  one wrapped with the bundled audit / budget / risk-tier / undo harness.
+- **Pipeline-failure RCA**: failed jobs classified from failure_reason +
+  trace-tail markers — test-failure, dependency/network, runner-timeout, OOM,
+  script error — each with matched evidence, cause, and action.
+- **Runner health & queue RCA**: offline/stale/paused runners, long-queued
+  jobs, per-tag saturation.
+- **Artifact/storage bloat**: projects ranked by repo + artifact bytes,
+  expired-but-kept artifacts, reclaimable estimate → feeds
+  `delete_artifacts --dry-run`.
+- **Stale-work audit**: idle MRs/branches and protection gaps (unprotected
+  default branch, force-push allowed).
+- **Writes with faithful before-state**: pause/resume runner is a true undo
+  pair; branch protection undo replays prior settings; pipeline retry/cancel
+  and artifact deletion record priorState (irreversible, artifact deletion is
+  risk=high behind the approver gate).
+- **Encrypted secrets** (Fernet + scrypt), TLS verify default ON, friendly
+  `init` wizard, `doctor` with version + token-scope probes.
+
+## Known limits (v0.1)
+
+- Preview / mock-only: modelled from public API docs, exercised against
+  mocked HTTP; not yet validated on live servers.
+- Runner administration, pipeline retry/cancel, and artifact deletion are
+  GitLab surfaces; on Gitea they raise a teaching error (no API v1
+  equivalent).
+- Self-managed instances only — GitLab.com / Gitea Cloud are out of scope.

cicd_aiops-0.1.0/SECURITY.md

@@ -0,0 +1,49 @@
+# Security Policy
+
+Community-maintained open-source project, **not affiliated with, endorsed by, or
+sponsored by GitLab Inc. or the Gitea project.**
+Product and trademark names (GitLab, Gitea) belong to their owners.
+
+## Reporting a vulnerability
+
+Open a private security advisory on GitHub
+(https://github.com/AIops-tools/CICD-AIops/security/advisories) or email
+zhouwei008@gmail.com. Please do not open public issues for exploitable bugs.
+
+## Credential handling
+
+- Per-target secrets — the GitLab personal/project access token or the Gitea
+  access token — are stored **encrypted** in `~/.cicd-aiops/secrets.enc`
+  (Fernet/AES-128-CBC+HMAC, key derived from a master password via scrypt),
+  file mode 600. Never plaintext on disk.
+- The token is presented as a `PRIVATE-TOKEN` header (GitLab) or an
+  `Authorization: token` header (Gitea) at request time and held only in
+  memory; secrets are never logged, echoed, or included in tool output.
+- A legacy plaintext env var (`CICD_<TARGET>_SECRET`) is honoured as a
+  fallback with a deprecation warning — migrate with
+  `cicd-aiops secret migrate`.
+- TLS verification defaults ON; disabling it is an explicit per-target,
+  wizard-confirmed choice intended for lab certs only.
+
+## Blast-radius controls
+
+- Every MCP tool and every CLI write runs through the `@governed_tool`
+  harness: audit log (`~/.cicd-aiops/audit.db`), call/time budgets, a runaway
+  breaker, graduated risk tiers, and undo-token recording.
+- Secure by default: with no `rules.yaml`, high-risk writes
+  (`delete_artifacts`) are denied unless `CICD_AUDIT_APPROVED_BY` names a
+  human approver.
+- Every write supports `dry_run`; the CLI double-confirms destructive
+  operations.
+
+## Input/output hardening
+
+- All server-returned text (job traces, MR titles, branch names, runner
+  descriptions) is folded through an injection-safe normaliser — bounded
+  string length, capped nesting depth — before an agent sees it.
+- All URL path parameters are percent-encoded; Gitea's `owner/repo` values
+  are validated per segment (empty/`.`/`..` rejected) so an agent-supplied
+  identifier can never rewrite a request path.
+
+No webhooks, no telemetry, no outbound calls beyond the configured GitLab /
+Gitea REST API.

cicd_aiops-0.1.0/cicd_aiops/__init__.py

@@ -0,0 +1,14 @@
+"""cicd-aiops — governed GitLab + Gitea CI/CD operations for AI agents.
+
+Standalone and self-contained: the governance harness (audit, token budget,
+undo-token recording, graduated risk tiers, output sanitize) is
+bundled under ``cicd_aiops.governance`` — this package has no external
+skill-family dependency. Preview: not yet full-coverage.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("cicd-aiops")
+except PackageNotFoundError:  # running from an uninstalled source tree
+    __version__ = "0.0.0+unknown"

cicd_aiops-0.1.0/cicd_aiops/cli/__init__.py

@@ -0,0 +1,9 @@
+"""CLI package for cicd-aiops.
+
+Re-exports ``app`` so the pyproject entry point
+``cicd-aiops = "cicd_aiops.cli:app"`` works unchanged.
+"""
+
+from cicd_aiops.cli._root import app
+
+__all__ = ["app"]