skills-manager-cli 0.1.0__tar.gz

skills_manager_cli-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,128 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+# Routing design (BL-073): `runs-on` cannot be conditional, so a cheap
+# probe carries the only signal that matters — hosted minutes. Skipped =
+# neutral gray, never red. Only real test failures go red:
+# - probe-hosted (hosted): green ⇔ minutes exist. Its red only ever means
+#   "no quota" (single echo step); it carries no code signal, ignore it.
+# - Hosted variants run only on proven quota (hosted first, no duplicates).
+# - Self-hosted variants run only when the probe shows no quota. They have
+#   no `needs` edge (nothing must gate them: when the box is down they
+#   queue honestly instead of deadlocking behind another job).
+# - preflight (self-hosted) translates the probe result into warnings and
+#   always exits 0. It cannot query runner presence: listing repo runners
+#   needs admin scope, which GITHUB_TOKEN can never have (403) — so no
+#   per-OS gating is attempted; an absent box shows as queued, not red.
+jobs:
+  probe-hosted:
+    runs-on: ubuntu-latest
+    outputs:
+      minutes_ok: ${{ steps.check.outputs.minutes_ok }}
+    steps:
+      - id: check
+        run: echo "minutes_ok=true" >> "$GITHUB_OUTPUT"
+
+  preflight:
+    runs-on: [self-hosted, linux]
+    needs: [probe-hosted]
+    if: always()
+    steps:
+      - run: |
+          if [ "${{ needs.probe-hosted.outputs.minutes_ok }}" = "true" ]; then
+            echo "Hosted minutes available — hosted jobs take it from here."
+          else
+            echo "::warning::Hosted minutes unavailable — hosted jobs will skip; self-hosted jobs (if their runners live) carry the signal."
+          fi
+
+  test-linux-hosted:
+    name: test (linux hosted 3.12)
+    needs: [probe-hosted]
+    if: needs.probe-hosted.outputs.minutes_ok == 'true'
+    strategy:
+      fail-fast: false
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+      - run: uv sync
+      - run: uv run python -m unittest discover -s tests
+      - run: uv run ruff check src tests
+
+  test-windows-hosted:
+    name: test (windows hosted 3.12)
+    needs: [probe-hosted]
+    if: needs.probe-hosted.outputs.minutes_ok == 'true'
+    strategy:
+      fail-fast: false
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+      - run: uv sync
+      - run: uv run python -m unittest discover -s tests
+      - run: uv run ruff check src tests
+
+  test-linux-selfhosted:
+    name: test (linux self-hosted 3.12)
+    needs: [probe-hosted]
+    if: always() && needs.probe-hosted.outputs.minutes_ok != 'true'
+    runs-on: [self-hosted, linux]
+    steps:
+      # Plain git: no actions/checkout (codeload.github.com is
+      # unreachable from here; the runner pre-downloads every `uses:`).
+      - name: Checkout (self-hosted)
+        run: |
+          set -e
+          if [ ! -d .git ]; then
+            git init -q
+            git remote add origin "https://github.com/${{ github.repository }}.git"
+          fi
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            git fetch --depth 1 origin "pull/${{ github.event.number }}/merge"
+          else
+            git fetch --depth 1 origin "${{ github.sha }}"
+          fi
+          git checkout -qf FETCH_HEAD
+          git clean -fdx
+      # System toolchain: no setup-uv (see above).
+      - name: Set up uv (self-hosted)
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "UV_PYTHON_PREFERENCE=only-system" >> "$GITHUB_ENV"
+          /home/alec/.local/bin/uv --version
+          python3 --version
+      - run: uv sync
+      - run: uv run python -m unittest discover -s tests
+      - run: uv run ruff check src tests
+
+  test-windows-selfhosted:
+    name: test (windows self-hosted 3.12)
+    needs: [probe-hosted]
+    if: always() && needs.probe-hosted.outputs.minutes_ok != 'true'
+    runs-on: [self-hosted, Windows]
+    steps:
+      # Plain git: no actions/checkout (see test-linux-selfhosted).
+      - name: Checkout (self-hosted)
+        run: |
+          if (-not (Test-Path .git)) {
+            git init -q
+            git remote add origin "https://github.com/${{ github.repository }}.git"
+          }
+          if ("${{ github.event_name }}" -eq "pull_request") {
+            git fetch --depth 1 origin "pull/${{ github.event.number }}/merge"
+          } else {
+            git fetch --depth 1 origin "${{ github.sha }}"
+          }
+          git checkout -qf FETCH_HEAD
+          git clean -fdx
+      - run: C:\Users\Dell\.local\bin\uv.exe sync --python 3.12
+      - run: C:\Users\Dell\.local\bin\uv.exe run python -m unittest discover -s tests
+      - run: C:\Users\Dell\.local\bin\uv.exe run ruff check src tests

skills_manager_cli-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,170 @@
+name: Release
+
+# BL-058: every merge to main cuts a new GitHub release (version stamp,
+# sdist/wheel, checksums.txt, tag, notes) with no manual steps.
+# BL-074: the same run then publishes the sdist/wheel to PyPI (trusted
+# publishing, no manual upload). A failed publish is retried via
+# workflow_dispatch with inputs.version — the exact bytes are
+# re-downloaded from the GitHub release, never rebuilt.
+#
+# Self-hosted job (BL-074): hosted minutes are exhausted, and no `uses:`
+# step resolves on the self-hosted runner (codeload.github.com is
+# unreachable from it) — so checkout/setup/publish are plain shell over
+# the system toolchain, mirroring ci.yml self-hosted jobs. Publishing
+# uses `uv publish` with forced OIDC (mechanism proven by the TestPyPI
+# rehearsal, run 38636537537). `gh` is preinstalled on the runner.
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Retry publishing an existing release, e.g. 0.1.3 (empty = normal auto-computed release)"
+        required: false
+        default: ""
+
+permissions:
+  contents: write
+  id-token: write # BL-074: OIDC trusted publishing to PyPI
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  release:
+    if: "!contains(github.event.head_commit.message, '[skip release]')"
+    runs-on: [self-hosted, linux]
+    steps:
+      # Plain git: no actions/checkout (see header) — full history so
+      # tag push works from any checkout state; tags needed for version
+      # computation below.
+      - name: Checkout (self-hosted)
+        run: |
+          set -e
+          if [ ! -d .git ]; then
+            git init -q
+            git remote add origin "https://github.com/${{ github.repository }}.git"
+          fi
+          git fetch --tags --force origin
+          git fetch origin "${{ github.ref }}"
+          git checkout -qf FETCH_HEAD
+          git clean -fdx
+
+      # System toolchain: no setup-uv (see header) — same as ci.yml.
+      - name: Set up uv (self-hosted)
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "UV_PYTHON_PREFERENCE=only-system" >> "$GITHUB_ENV"
+          /home/alec/.local/bin/uv --version
+          python3 --version
+
+      - name: Compute next version
+        id: version
+        run: |
+          set -eu
+          git fetch --tags --force
+          if [ -n "${{ inputs.version }}" ]; then
+            requested="${{ inputs.version }}"
+            if ! printf '%s' "$requested" | grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+$'; then
+              echo "inputs.version must be numeric X.Y.Z with no 'v' prefix (got: $requested)." >&2
+              exit 1
+            fi
+            if ! git rev-parse "v$requested" >/dev/null 2>&1; then
+              echo "Tag v$requested does not exist; a recovery dispatch requires an existing release." >&2
+              exit 1
+            fi
+            echo "next=$requested" >> "$GITHUB_OUTPUT"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+            echo "recovery=true" >> "$GITHUB_OUTPUT"
+            echo "Recovery publish for existing release v$requested."
+            exit 0
+          fi
+          echo "recovery=false" >> "$GITHUB_OUTPUT"
+          latest="$(git tag --list 'v*' --sort=-v:refname | head -n 1 || true)"
+          if [ -z "$latest" ]; then
+            next="0.1.0"
+          else
+            base="${latest#v}"
+            major="${base%%.*}"
+            rest="${base#*.}"
+            minor="${rest%%.*}"
+            patch="${rest#*.}"
+            next="$major.$minor.$((patch + 1))"
+          fi
+          if git rev-parse "v$next" >/dev/null 2>&1; then
+            echo "Tag v$next already exists; nothing to release."
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "next=$next" >> "$GITHUB_OUTPUT"
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+          fi
+          echo "Next version: $next (latest tag: ${latest:-none})"
+
+      - name: Stamp version and push tag
+        if: steps.version.outputs.skip == 'false'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -eu
+          next="${{ steps.version.outputs.next }}"
+          sed -i "s/^version = \".*\"/version = \"$next\"/" pyproject.toml
+          sed -i "s/^__version__ = \".*\"/__version__ = \"$next\"/" src/skills_manager/__init__.py
+          grep -q "^version = \"$next\"$" pyproject.toml
+          grep -q "^__version__ = \"$next\"$" src/skills_manager/__init__.py
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml src/skills_manager/__init__.py
+          git commit -m "chore: release v$next [skip release]"
+          git tag "v$next"
+          # Plain-git checkout has no credential helper (no
+          # actions/checkout), so authenticate the push explicitly.
+          auth="$(printf 'x-access-token:%s' "$GITHUB_TOKEN" | base64 -w0)"
+          git -c "http.extraHeader=AUTHORIZATION: basic $auth" push origin HEAD:main "v$next"
+
+      - name: Build packages and checksums
+        if: steps.version.outputs.skip == 'false'
+        run: |
+          set -eu
+          uv sync
+          uv build
+          (cd dist && sha256sum -- * > checksums.txt)
+          cat dist/checksums.txt
+
+      - name: Create GitHub release with notes
+        if: steps.version.outputs.skip == 'false'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -eu
+          next="${{ steps.version.outputs.next }}"
+          gh release create "v$next" --title "v$next" --generate-notes dist/*
+
+      - name: Stage distributions for PyPI (BL-074)
+        if: steps.version.outputs.skip == 'false' || steps.version.outputs.recovery == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -eu
+          next="${{ steps.version.outputs.next }}"
+          rm -rf dist-publish
+          mkdir -p dist-publish
+          if [ "${{ steps.version.outputs.recovery }}" = "true" ]; then
+            gh release download "v$next" --pattern '*.tar.gz' --pattern '*.whl' --dir dist-publish
+          else
+            cp dist/*.tar.gz dist/*.whl dist-publish/
+          fi
+          echo "Upload set:"
+          ls -la dist-publish
+          count="$(ls dist-publish/*.tar.gz dist-publish/*.whl 2>/dev/null | wc -l)"
+          if [ "$count" -lt 2 ]; then
+            echo "Expected at least one sdist and one wheel in dist-publish/." >&2
+            exit 1
+          fi
+
+      - name: Publish to PyPI (BL-074)
+        if: steps.version.outputs.skip == 'false' || steps.version.outputs.recovery == 'true'
+        run: |
+          set -eu
+          uv publish --trusted-publishing always dist-publish/*

skills_manager_cli-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+venv/
+build/
+dist/
+*.egg
+
+# Tooling / caches
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# OS / editor
+.DS_Store
+.vscode/
+.idea/

skills_manager_cli-0.1.0/.opencode/commands/speckit.analyze.md

@@ -0,0 +1,251 @@
+---
+description: Perform a non-destructive cross-artifact consistency and quality analysis across spec.md, plan.md, and tasks.md after task generation.
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Pre-Execution Checks
+
+**Check for extension hooks (before analysis)**:
+- Check if `.specify/extensions.yml` exists in the project root.
+- If it exists, read it and look for entries under the `hooks.before_analyze` key
+- If the YAML cannot be parsed or is invalid, do not skip silently: tell the user that `.specify/extensions.yml` could not be read (include the parser error) and that no hooks were checked, including any mandatory (`optional: false`) hooks registered there, then continue normally
+- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+- For each executable hook, output the following based on its `optional` flag:
+  - **Optional hook** (`optional: true`):
+    ```
+    ## Extension Hooks
+
+    **Optional Pre-Hook**: {extension}
+    Command: `/{command}`
+    Description: {description}
+
+    Prompt: {prompt}
+    To execute: `/{command}`
+    ```
+  - **Mandatory hook** (`optional: false`):
+    ```
+    ## Extension Hooks
+
+    **Automatic Pre-Hook**: {extension}
+    Executing: `/{command}`
+    EXECUTE_COMMAND: {command}
+
+    Wait for the result of the hook command before proceeding to the Goal.
+    ```
+    After emitting the block above you MUST actually invoke the hook and wait for it to finish before continuing. Run it the same way you would run the command yourself in this agent/session (the invocation may differ from the literal `{command}` id shown above, e.g. a skills-mode agent runs it as `/skill:speckit-...` or `$speckit-...`). Emitting the block alone does not run the hook.
+- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Goal
+
+Identify inconsistencies, duplications, ambiguities, and underspecified items across the three core artifacts (`spec.md`, `plan.md`, `tasks.md`) before implementation. This command MUST run only after `/speckit.tasks` has successfully produced a complete `tasks.md`.
+
+## Operating Constraints
+
+**STRICTLY READ-ONLY**: Do **not** modify any files. Output a structured analysis report. Offer an optional remediation plan (user must explicitly approve before any follow-up editing commands would be invoked manually).
+
+**Constitution Authority**: The project constitution (`.specify/memory/constitution.md`) is **non-negotiable** within this analysis scope. Constitution conflicts are automatically CRITICAL and require adjustment of the spec, plan, or tasks—not dilution, reinterpretation, or silent ignoring of the principle. If a principle itself needs to change, that must occur in a separate, explicit constitution update outside `/speckit.analyze`.
+
+## Execution Steps
+
+### 1. Initialize Analysis Context
+
+Run `.specify/scripts/bash/check-prerequisites.sh --json --require-spec --require-tasks --include-tasks` once from repo root and parse JSON for FEATURE_DIR and AVAILABLE_DOCS. Derive absolute paths:
+
+- SPEC = FEATURE_DIR/spec.md
+- PLAN = FEATURE_DIR/plan.md
+- TASKS = FEATURE_DIR/tasks.md
+
+Abort with an error message if any required file is missing (instruct the user to run missing prerequisite command).
+For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+
+### 2. Load Artifacts (Progressive Disclosure)
+
+Load only the minimal necessary context from each artifact:
+
+**From spec.md:**
+
+- Overview/Context
+- Functional Requirements
+- Success Criteria (measurable outcomes — e.g., performance, security, availability, user success, business impact)
+- User Stories
+- Edge Cases (if present)
+
+**From plan.md:**
+
+- Architecture/stack choices
+- Data Model references
+- Phases
+- Technical constraints
+
+**From tasks.md:**
+
+- Task IDs
+- Descriptions
+- Phase grouping
+- Parallel markers [P]
+- Referenced file paths
+
+**From constitution:**
+
+- Load `.specify/memory/constitution.md` for principle validation
+
+### 3. Build Semantic Models
+
+Create internal representations (do not include raw artifacts in output):
+
+- **Requirements inventory**: For each Functional Requirement (FR-###) and Success Criterion (SC-###), record a stable key. Use the explicit FR-/SC- identifier as the primary key when present, and optionally also derive an imperative-phrase slug for readability (e.g., "User can upload file" → `user-can-upload-file`). Include only Success Criteria items that require buildable work (e.g., load-testing infrastructure, security audit tooling), and exclude post-launch outcome metrics and business KPIs (e.g., "Reduce support tickets by 50%").
+- **User story/action inventory**: Discrete user actions with acceptance criteria
+- **Task coverage mapping**: Map each task to one or more requirements or stories (inference by keyword / explicit reference patterns like IDs or key phrases)
+- **Constitution rule set**: Extract principle names and MUST/SHOULD normative statements
+
+### 4. Detection Passes (Token-Efficient Analysis)
+
+Focus on high-signal findings. Limit to 50 findings total; aggregate remainder in overflow summary.
+
+#### A. Duplication Detection
+
+- Identify near-duplicate requirements
+- Mark lower-quality phrasing for consolidation
+
+#### B. Ambiguity Detection
+
+- Flag vague adjectives (fast, scalable, secure, intuitive, robust) lacking measurable criteria
+- Flag unresolved placeholders (TODO, TKTK, ???, `<placeholder>`, etc.)
+
+#### C. Underspecification
+
+- Requirements with verbs but missing object or measurable outcome
+- User stories missing acceptance criteria alignment
+- Tasks referencing files or components not defined in spec/plan
+
+#### D. Constitution Alignment
+
+- Any requirement or plan element conflicting with a MUST principle
+- Missing mandated sections or quality gates from constitution
+
+#### E. Coverage Gaps
+
+- Requirements with zero associated tasks
+- Tasks with no mapped requirement/story
+- Success Criteria requiring buildable work (performance, security, availability) not reflected in tasks
+
+#### F. Inconsistency
+
+- Terminology drift (same concept named differently across files)
+- Data entities referenced in plan but absent in spec (or vice versa)
+- Task ordering contradictions (e.g., integration tasks before foundational setup tasks without dependency note)
+- Conflicting requirements (e.g., one requires Next.js while other specifies Vue)
+
+### 5. Severity Assignment
+
+Use this heuristic to prioritize findings:
+
+- **CRITICAL**: Violates constitution MUST, missing core spec artifact, or requirement with zero coverage that blocks baseline functionality
+- **HIGH**: Duplicate or conflicting requirement, ambiguous security/performance attribute, untestable acceptance criterion
+- **MEDIUM**: Terminology drift, missing non-functional task coverage, underspecified edge case
+- **LOW**: Style/wording improvements, minor redundancy not affecting execution order
+
+### 6. Produce Compact Analysis Report
+
+Output a Markdown report (no file writes) with the following structure:
+
+## Specification Analysis Report
+
+| ID | Category | Severity | Location(s) | Summary | Recommendation |
+|----|----------|----------|-------------|---------|----------------|
+| A1 | Duplication | HIGH | spec.md:L120-134 | Two similar requirements ... | Merge phrasing; keep clearer version |
+
+(Add one row per finding; generate stable IDs prefixed by category initial.)
+
+**Coverage Summary Table:**
+
+| Requirement Key | Has Task? | Task IDs | Notes |
+|-----------------|-----------|----------|-------|
+
+**Constitution Alignment Issues:** (if any)
+
+**Unmapped Tasks:** (if any)
+
+**Metrics:**
+
+- Total Requirements
+- Total Tasks
+- Coverage % (requirements with >=1 task)
+- Ambiguity Count
+- Duplication Count
+- Critical Issues Count
+
+### 7. Provide Next Actions
+
+At end of report, output a concise Next Actions block:
+
+- If CRITICAL issues exist: Recommend resolving before `/speckit.implement`
+- If only LOW/MEDIUM: User may proceed, but provide improvement suggestions
+- Provide explicit command suggestions: e.g., "Run /speckit.specify with refinement", "Run /speckit.plan to adjust architecture", "Manually edit tasks.md to add coverage for 'performance-metrics'"
+
+### 8. Offer Remediation
+
+Ask the user: "Would you like me to suggest concrete remediation edits for the top N issues?" (Do NOT apply them automatically.)
+
+### 9. Check for extension hooks
+
+After reporting, check if `.specify/extensions.yml` exists in the project root.
+- If it exists, read it and look for entries under the `hooks.after_analyze` key
+- If the YAML cannot be parsed or is invalid, do not skip silently: tell the user that `.specify/extensions.yml` could not be read (include the parser error) and that no hooks were checked, including any mandatory (`optional: false`) hooks registered there, then continue normally
+- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+- For each executable hook, output the following based on its `optional` flag:
+  - **Optional hook** (`optional: true`):
+    ```
+    ## Extension Hooks
+
+    **Optional Hook**: {extension}
+    Command: `/{command}`
+    Description: {description}
+
+    Prompt: {prompt}
+    To execute: `/{command}`
+    ```
+  - **Mandatory hook** (`optional: false`):
+    ```
+    ## Extension Hooks
+
+    **Automatic Hook**: {extension}
+    Executing: `/{command}`
+    EXECUTE_COMMAND: {command}
+    ```
+    After emitting the block above you MUST actually invoke the hook and wait for it to finish before continuing. Run it the same way you would run the command yourself in this agent/session (the invocation may differ from the literal `{command}` id shown above, e.g. a skills-mode agent runs it as `/skill:speckit-...` or `$speckit-...`). Emitting the block alone does not run the hook.
+- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Operating Principles
+
+### Context Efficiency
+
+- **Minimal high-signal tokens**: Focus on actionable findings, not exhaustive documentation
+- **Progressive disclosure**: Load artifacts incrementally; don't dump all content into analysis
+- **Token-efficient output**: Limit findings table to 50 rows; summarize overflow
+- **Deterministic results**: Rerunning without changes should produce consistent IDs and counts
+
+### Analysis Guidelines
+
+- **NEVER modify files** (this is read-only analysis)
+- **NEVER hallucinate missing sections** (if absent, report them accurately)
+- **Prioritize constitution violations** (these are always CRITICAL)
+- **Use examples over exhaustive rules** (cite specific instances, not generic patterns)
+- **Report zero issues gracefully** (emit success report with coverage statistics)
+
+## Context
+
+$ARGUMENTS