spec-agent-cli 0.1.0__py3-none-any.whl

spec_agent/resources/skills/spec-evolution/scripts/timeline.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Render deterministic Markdown and Mermaid from an evolution JSONL log."""
+
+# spec: ELOG-005
+
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, NamedTuple
+
+
+class EvolutionEvent(NamedTuple):
+    event_id: str
+    timestamp: str
+    source: str
+    title: str
+    task_type: str
+    intent: str
+    behavior_ids: tuple[str, ...]
+    decision: str
+    rationale: str
+    spec_delta: str
+    supersedes: str
+
+
+def read_events(events_log: Path) -> list[EvolutionEvent]:
+    events: list[EvolutionEvent] = []
+    for line_number, line in enumerate(
+        events_log.read_text(encoding="utf-8").splitlines(), 1
+    ):
+        if not line.strip():
+            continue
+        try:
+            value = json.loads(line)
+        except json.JSONDecodeError as error:
+            raise ValueError(
+                f"invalid JSONL at {events_log}: line {line_number}: {error.msg}"
+            ) from error
+        if not isinstance(value, dict):
+            raise ValueError(
+                f"invalid JSONL at {events_log}: line {line_number}: expected object"
+            )
+        events.append(parse_event(value, f"line {line_number}"))
+    return sorted(events, key=lambda event: (_timestamp_key(event.timestamp), event.source))
+
+
+def parse_event(value: dict[str, Any], source: str) -> EvolutionEvent:
+    return EvolutionEvent(
+        event_id=_text(value.get("id")),
+        timestamp=_text(value.get("timestamp")),
+        source=source,
+        title=_text(value.get("title")),
+        task_type=_text(value.get("task_type")),
+        intent=_text(value.get("user_intent")),
+        behavior_ids=_string_list(value.get("behavior_ids")),
+        decision=_text(value.get("decision")),
+        rationale=_text(value.get("rationale")),
+        spec_delta=_text(value.get("spec_delta")),
+        supersedes=_text(value.get("supersedes")),
+    )
+
+
+def render_markdown(events: list[EvolutionEvent]) -> str:
+    lines = [
+        "<!-- Generated from spec/evolution/events.jsonl by .agents/skills/spec-evolution/scripts/timeline.py; do not edit. -->",
+        "# Specification Evolution Timeline",
+        "",
+    ]
+    for event in events:
+        behaviors = ", ".join(event.behavior_ids) or "missing"
+        lines.extend(
+            [
+                f"## {event.timestamp} — {event.title}",
+                "",
+                f"- Event: {event.event_id}",
+                f"- Task type: {event.task_type}",
+                f"- User intent: {event.intent}",
+                f"- Behavior IDs: {behaviors}",
+                f"- Product decision: {event.decision}",
+                f"- Rationale: {event.rationale}",
+                f"- Specification delta: {event.spec_delta}",
+                f"- Supersedes: {event.supersedes}",
+                "",
+            ]
+        )
+    lines.extend(
+        ["## Mermaid", "", "```mermaid", "timeline", "  title Specification Evolution"]
+    )
+    for event in events:
+        label = _mermaid_text(f"{event.event_id} — {event.title}")
+        lines.append(f"  {event.timestamp} : {label}")
+    lines.extend(["```", ""])
+    return "\n".join(lines)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Render specification evolution events.")
+    parser.add_argument("--log", "--events", dest="events", type=Path, required=True)
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args(argv)
+    if not args.events.is_file():
+        parser.error(f"event log does not exist: {args.events}")
+    output = render_markdown(read_events(args.events))
+    if args.output:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(output, encoding="utf-8")
+    else:
+        print(output, end="")
+    return 0
+
+
+def _text(value: Any) -> str:
+    return value.strip() if isinstance(value, str) and value.strip() else "missing"
+
+
+def _string_list(value: Any) -> tuple[str, ...]:
+    if not isinstance(value, list):
+        return ()
+    return tuple(item.strip() for item in value if isinstance(item, str) and item.strip())
+
+
+def _timestamp_key(value: str) -> tuple[int, str]:
+    try:
+        datetime.fromisoformat(value.replace("Z", "+00:00"))
+        return (0, value)
+    except ValueError:
+        return (1, value)
+
+
+def _mermaid_text(value: str) -> str:
+    return value.replace(":", "-").replace("\n", " ").strip() or "missing"
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

spec_agent/resources/skills/spec-request-flow/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: spec-request-flow
+description: Use when a user asks to add, change, fix, refactor, design, or implement repository behavior under spec-driven development, including vague requests and follow-ups that modify an existing feature even when specifications are not mentioned.
+---
+
+# Spec Request Flow
+
+Produce an approved, implementation-independent product specification, then stop with
+a discoverable Code Agent handoff.
+
+<HARD-GATE>
+Do not scaffold or write specification files before the user approves the presented
+product decisions. Do not create an implementation plan, choose repository files,
+write code or tests, dispatch implementation, or perform engineering verification at
+any point in this skill.
+</HARD-GATE>
+
+## Explore context
+
+1. Read applicable `AGENTS.md`, root `SPEC.md`, the existing feature packet, relevant
+   product behavior, and related `spec/evolution/events.jsonl` entries.
+2. Separate evidence, outcomes, conflicts, assumptions, and unknowns.
+3. If the request contains independent subsystems, propose decomposition and process
+   one independently valuable feature at a time.
+
+## Clarify product behavior
+
+1. Ask one blocking question at a time. Do not ask what repository evidence answers.
+2. For each material product decision, present 2-3 approaches, trade-offs, and a
+   recommendation. Keep choices about observable behavior, not technical solutions.
+3. Cover actors, rules, conceptual data, primary and alternate flows, failures,
+   recovery, states, edges, permissions, privacy, defaults, constraints, non-goals,
+   and measurable outcomes.
+4. Label every unresolved item `blocking` or `non-blocking`. Never turn an assumption
+   into an accepted requirement.
+
+## Requirements-completeness gate
+
+Verify every category above before presenting the product decision. Continue while any
+blocking item remains. Defer one only when the user approves a stated default.
+
+## Product-decision approval gate
+
+Present the proposed product behavior and ask the user to approve or revise it. Do not
+scaffold or write either specification file while approval is absent or ambiguous.
+
+## Write and self-review the specification
+
+1. Reuse `spec/features/<feature-slug>/` when present; otherwise run
+   `scripts/create_feature.py <feature-slug> --title "Feature Title"`.
+2. Read [references/spec-format.md](references/spec-format.md). Write both `spec.md`
+   and `acceptance.md`; add both paths to root `SPEC.md`.
+3. Keep both files strictly product-facing. Do not include code paths, symbols,
+   frameworks, storage choices, ordered engineering steps, test files, commands,
+   deployment instructions, or code backlinks.
+4. Run the complete self-review on both files and fix every finding.
+
+## Written-spec approval gate
+
+Show both paths and summarize their delta. Ask for explicit written-spec approval. If
+revised, update both files, rerun self-review, and ask again.
+
+## Completion and Code Agent handoff
+
+After approval, mark both files `approved`, use `spec-evolution` to record the approved
+product decision, and stop. `spec-drift-sync` is used later as a read-only observer;
+it is not implementation work for this skill.
+
+Output exactly the following, replacing `[SPEC_PATH]` with the actual `spec.md` path:
+
+Spec complete. To implement this, give your Code Agent the following prompt: 'Read the specification at [SPEC_PATH] and generate an implementation plan.'
+
+Do not append planning advice, implementation steps, or an offer to write code.
+
+## Later changes
+
+A later prompt updates the same two-file packet and preserves stable behavior IDs.
+Return to clarification and both approval gates for every normative product change.

spec_agent/resources/skills/spec-request-flow/assets/SPEC.template.md

@@ -0,0 +1,41 @@
+---
+id: SPEC-PROJECT
+title: Project Specification Index
+status: draft
+version: 0.1.0
+---
+
+# Project Specification Index
+
+## Purpose and boundaries
+
+Describe the product, users, goals, constraints, and non-goals.
+
+## Source-of-truth rules
+
+Identify normative product specifications, generated traceability data, and historical
+product-decision records without mixing their authority.
+
+## Repository-wide behaviors
+
+PROJECT-001: Write one testable current-state requirement.
+
+## Feature specifications
+
+List each accepted or active feature and link both normative product files:
+
+- `spec/features/feature-name/spec.md`
+- `spec/features/feature-name/acceptance.md`
+
+## Repository-wide interfaces, state, and failures
+
+Describe externally observable contracts, persistent state, invariants, failure
+behavior, security, and privacy constraints.
+
+## Open questions
+
+List unresolved decisions. Do not represent them as accepted requirements.
+
+## Acceptance criteria
+
+- AC-PROJECT-001: State observable evidence for PROJECT-001.

spec_agent/resources/skills/spec-request-flow/assets/feature-acceptance.template.md

@@ -0,0 +1,46 @@
+---
+id: {{BEHAVIOR_PREFIX}}-ACCEPTANCE
+title: {{FEATURE_TITLE}} Acceptance Specification
+status: draft
+related_spec: spec.md
+created: {{DATE}}
+---
+
+# {{FEATURE_TITLE}} Acceptance Specification
+
+This file defines observable product acceptance for the rules in `spec.md`. It does
+not select implementation files, technologies, test frameworks, or commands.
+
+## Acceptance scope
+
+State which product outcomes and actors this acceptance specification covers.
+
+## Behavior acceptance
+
+For every business-rule ID in `spec.md`, describe observable Given/When/Then outcomes.
+Use acceptance IDs beginning with `AC-{{BEHAVIOR_PREFIX}}-001`.
+
+## Alternative and failure acceptance
+
+Cover alternate paths, denied actions, invalid inputs, failures, and recovery outcomes.
+
+## Edge cases
+
+List boundary conditions, empty states, concurrency-visible outcomes, repeated actions,
+partial completion, and other product-significant edges.
+
+## Exception policy
+
+State permitted exceptions, who may authorize them, and the observable audit outcome.
+
+## Permissions and privacy acceptance
+
+Describe observable authorization, disclosure, retention, and privacy outcomes.
+
+## Acceptance dependencies
+
+List product assumptions or external business conditions required to evaluate outcomes.
+
+## Unresolved acceptance decisions
+
+Label each item `blocking` or `non-blocking`. Approved acceptance has no blocking item.

spec_agent/resources/skills/spec-request-flow/assets/feature-spec.template.md

@@ -0,0 +1,71 @@
+---
+id: {{BEHAVIOR_PREFIX}}
+title: {{FEATURE_TITLE}}
+status: draft
+created: {{DATE}}
+---
+
+# {{FEATURE_TITLE}} Specification
+
+Companion acceptance specification: `acceptance.md`.
+
+## Problem and desired outcome
+
+State the user or business problem, the desired observable outcome, and why it matters.
+
+## Users and actors
+
+Identify each human, organization, or external system involved and its product role.
+
+## Scope and non-goals
+
+State included product behavior, boundaries, constraints, and explicit non-goals.
+
+## Definitions
+
+Define product terms that could otherwise have multiple interpretations.
+
+## Approved product decisions
+
+Record the chosen product behavior, alternatives considered, trade-offs, rationale,
+and approving authority. Do not prescribe a technical solution.
+
+## Conceptual data model
+
+Describe business entities, relationships, ownership, lifecycle, and invariants without
+choosing storage technology or repository structures.
+
+## Business rules
+
+Add current-state normative requirements beginning with `{{BEHAVIOR_PREFIX}}-001`.
+Use observable `MUST`, `SHOULD`, or `MAY` language and keep IDs stable.
+
+## Preconditions and postconditions
+
+Define what must be true before each material action and what becomes true afterward.
+
+## Primary user flows
+
+Describe successful actor journeys in business terms.
+
+## Alternative and failure flows
+
+Describe alternate paths, rejected actions, failures, and recovery behavior.
+
+## States and transitions
+
+Define product-visible states, allowed transitions, terminal states, and invariants.
+
+## Permissions, privacy, and compliance
+
+Define who may do what, protected information, retention or disclosure rules, and
+applicable compliance constraints. State when a category is not applicable.
+
+## Constraints and defaults
+
+Record product constraints, default behavior, compatibility expectations, and non-goals.
+
+## Assumptions and unresolved decisions
+
+Label each item `blocking` or `non-blocking`. An approved specification contains no
+blocking item; deferred non-blocking items include an accepted default.

spec_agent/resources/skills/spec-request-flow/references/spec-format.md

@@ -0,0 +1,60 @@
+# Specification Format
+
+Root `SPEC.md` is the product-wide contract and feature index. Each material feature
+lives in `spec/features/<feature-slug>/` and contains exactly two product artifacts:
+
+- `spec.md`: normative product rules, actors, conceptual data, flows, states,
+  permissions, constraints, and approved decisions;
+- `acceptance.md`: observable acceptance scenarios, failure outcomes, edge cases,
+  and exception policy mapped to stable behavior IDs.
+
+Both files describe **what must be true**, never how software will be built. They must
+not contain repository paths, code symbols, libraries, frameworks, storage choices,
+implementation sequences, test filenames, commands, deployment instructions, or code
+backlinks. Root `SPEC.md` links both files. Derived code linkage belongs only in
+`spec/traceability.json`, which is not normative.
+
+## Lifecycle
+
+- `draft`: product behavior or acceptance remains incomplete or unapproved;
+- `product-approved`: the presented product decisions are approved and may be written;
+- `approved`: both self-reviewed files received explicit written-spec approval;
+- `superseded`: a later approved contract replaced this feature specification.
+
+Implementation and verification status never changes the meaning or status of an
+approved product specification. Keep behavior IDs stable across revisions. Record
+approved transitions in evolution history; keep current truth in the two spec files.
+
+Use `scripts/create_feature.py <feature-slug> --title "Feature Title"` to create the
+two-file packet without overwriting existing work. Replace every instruction with
+feature-specific content before requesting approval.
+
+## Requirements-completeness checklist
+
+Before writing, evaluate actors, business rules, conceptual entities and invariants,
+primary and alternate flows, failure and recovery behavior, states, edge cases,
+permissions, privacy, defaults, constraints, non-goals, and measurable outcomes.
+Label every unresolved item `blocking` or `non-blocking`; approved specs have no
+blocking items.
+
+## Spec self-review
+
+Run every check on both files before requesting written-spec approval.
+
+1. **Placeholder scan:** Remove templates, empty required sections, `TBD`, `TODO`, and
+   vague promises.
+2. **Internal consistency:** Ensure terms, rules, data, flows, states, and outcomes do
+   not contradict one another.
+3. **Scope:** Keep one independently valuable feature per packet.
+4. **Ambiguity:** Define actors, terms, authority, defaults, boundaries, and outcomes.
+5. **Testability:** Make every rule observable without prescribing engineering tests.
+6. **Failure, security, and privacy:** State failure, recovery, authorization, data
+   handling, and non-disclosure outcomes, or explicitly mark them not applicable.
+7. **Unique ownership:** Give each normative rule one stable behavior ID and one owner.
+8. **Acceptance coverage:** Map every behavior ID to at least one acceptance scenario;
+   ensure every scenario names the behavior it covers.
+9. **Implementation-content scan:** Remove paths, code names, technology choices,
+   ordered build steps, commands, and backlinks.
+
+After approval, revise product meaning only through the complete clarification and
+approval workflow. Git owns line diffs; evolution history owns decision sequence.

spec_agent/resources/skills/spec-request-flow/scripts/create_feature.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Create a non-overwriting two-file feature specification packet."""
+
+# spec: FSP-001, FSP-002, FSP-003
+
+from __future__ import annotations
+
+import argparse
+import re
+from datetime import UTC, datetime
+from pathlib import Path
+
+
+SLUG = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
+TEMPLATES = {
+    "spec.md": "feature-spec.template.md",
+    "acceptance.md": "feature-acceptance.template.md",
+}
+
+
+def create_packet(repo: Path, slug: str, title: str | None = None) -> Path:
+    if not SLUG.fullmatch(slug):
+        raise ValueError("feature slug must use lowercase kebab-case")
+
+    feature_title = title or slug.replace("-", " ").title()
+    behavior_prefix = slug.upper()
+    created = datetime.now(UTC).date().isoformat()
+    assets = Path(__file__).resolve().parent.parent / "assets"
+    replacements = {
+        "{{FEATURE_TITLE}}": feature_title,
+        "{{BEHAVIOR_PREFIX}}": behavior_prefix,
+        "{{DATE}}": created,
+    }
+    rendered: dict[str, str] = {}
+    for output_name, template_name in TEMPLATES.items():
+        text = (assets / template_name).read_text(encoding="utf-8")
+        for token, value in replacements.items():
+            text = text.replace(token, value)
+        rendered[output_name] = text
+
+    target = repo.resolve() / "spec/features" / slug
+    target.mkdir(parents=True, exist_ok=False)
+    for output_name, text in rendered.items():
+        (target / output_name).write_text(text, encoding="utf-8")
+    return target
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("slug")
+    parser.add_argument("--title")
+    parser.add_argument("--repo", type=Path, default=Path("."))
+    args = parser.parse_args(argv)
+    try:
+        target = create_packet(args.repo, args.slug, args.title)
+    except (FileExistsError, FileNotFoundError, OSError, ValueError) as error:
+        parser.error(str(error))
+    print(target)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

spec_agent_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: spec-agent-cli
+Version: 0.1.0
+Summary: A strict Spec Agent workflow for spec-driven development
+Author: Spec Agent contributors
+License: MIT
+License-File: LICENSE
+Keywords: agent-skills,ai-agent,cli,spec,spec-driven-development
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# Spec Agent CLI
+
+Spec Agent turns unclear feature requests into approved, product-only specifications
+before any implementation planning begins. It installs three Agent Skills under the
+open `.agents/skills` convention and keeps specification evolution and code drift
+observation available without mixing them into implementation work.
+
+## Install
+
+Python 3.11 or newer is required.
+
+```sh
+uv tool install spec-agent-cli
+```
+
+Alternatives:
+
+```sh
+pipx install spec-agent-cli
+pip install spec-agent-cli
+```
+
+## Initialize a repository
+
+```sh
+cd /path/to/your-project
+spec-agent init
+```
+
+This creates only missing project files and installs:
+
+```text
+.agents/skills/spec-request-flow/
+.agents/skills/spec-drift-sync/
+.agents/skills/spec-evolution/
+AGENTS.md                         # managed rules block; user content is preserved
+SPEC.md                           # created only when absent
+spec/features/
+spec/evolution/events.jsonl
+spec/evolution/timeline.md
+spec/traceability.json
+```
+
+Use `spec-agent init --check` for a read-only status check. Use
+`spec-agent init --force` to refresh locally modified managed skill files after a CLI
+upgrade. `--force` never replaces project specifications or history.
+
+## Start a feature
+
+Ask a compatible agent:
+
+```text
+Use spec-request-flow to define feature X. Do not implement it.
+```
+
+The Spec Agent repeatedly clarifies blocking product questions, compares meaningful
+product approaches, writes `spec.md` and `acceptance.md`, asks for approval, records
+the approved product evolution, and then gives you the prompt for a separate Code
+Agent.
+
+## License
+
+MIT

spec_agent_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+spec_agent/__init__.py,sha256=PBkRLfmwQJkk4ZmVw1C3HyD88cq_RogMOQkDAW3SLis,195
+spec_agent/__main__.py,sha256=ePZoyjzMWVBd_04PZCxBhYD7wzEOEAYrqg9_a07Xgd0,130
+spec_agent/cli.py,sha256=msq9XQhceHeaEuCfpZ4AOXGEU4rfaW4l_uZ9lNBZr8s,1748
+spec_agent/installer.py,sha256=L-0hSOmw6-IiYpRlK0qX_E_Urw9Xp5ji-aVWzrpbRLM,6300
+spec_agent/package_assets.py,sha256=I4VwlpmgBIB8VFsWoPKdcL_U327ScG1oJ-SPW7PmAsE,1613
+spec_agent/commands/__init__.py,sha256=zXGX0Y-dHjhJ31h43oz3PIKz0QwkCldqv4yIfT2hgdY,42
+spec_agent/commands/init.py,sha256=X3HW8eyrzISOdsxdERC8L7XIqSQjcJ9ZcL1GaLgeAJY,941
+spec_agent/resources/project-rules.md,sha256=BFoo1zaB_IrXohtqNc4WDrUGwaQBVS6PodRzG3BYbPY,852
+spec_agent/resources/skills/spec-drift-sync/SKILL.md,sha256=jcMf6lUV0pb9Va0LeD4lVdwZmIqE68-b83n_Xg09k20,2758
+spec_agent/resources/skills/spec-drift-sync/scripts/check.py,sha256=sFXZ-KF12l9ZsSsiKbliV48owOzby2IJE9AimAYIEUo,12806
+spec_agent/resources/skills/spec-evolution/SKILL.md,sha256=2Gu4b9VFr_JFCVaOg7hP2_2vrRcBKqbnB4Xq33GHacM,2758
+spec_agent/resources/skills/spec-evolution/scripts/record.py,sha256=18OK-4DuEgzxFd5Z8IOOASY3P7AxPRXwcZN3PHgRAPs,4688
+spec_agent/resources/skills/spec-evolution/scripts/timeline.py,sha256=NDmJsq2IobNp1tPEUM8Lwp9248NT7BfxYGwchUxxVwU,4550
+spec_agent/resources/skills/spec-request-flow/SKILL.md,sha256=KJNHmRGBY6UKVpfoI5E6uJ_W0GCvnaaxRehaJP1iA6c,3664
+spec_agent/resources/skills/spec-request-flow/assets/SPEC.template.md,sha256=gp810LXihTuxf9G5xfptdj3pfP23_-Kzq2fNkwju9fU,1021
+spec_agent/resources/skills/spec-request-flow/assets/feature-acceptance.template.md,sha256=WI13jyXSEE_sy_4lh_X1ophro1mPJ9G6b7mcRx7zpOM,1390
+spec_agent/resources/skills/spec-request-flow/assets/feature-spec.template.md,sha256=U1DzVyvbfSifwHT9bRehe-rEBH9lPEWp5tkedzylCYs,2071
+spec_agent/resources/skills/spec-request-flow/references/spec-format.md,sha256=yxUgeGUHmcJtpLsnE8TWiJUTZY8aPlCUjCY9wKgq2hY,3290
+spec_agent/resources/skills/spec-request-flow/scripts/create_feature.py,sha256=dcTnIPiADOAMFsU0tmLBBIQerRe_zk3VrvFbLhNTzTM,2029
+spec_agent_cli-0.1.0.dist-info/METADATA,sha256=mhHpbejCL2N2wENKACxh2vWkZVJ32vVTsnorNrYFg3Q,2470
+spec_agent_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+spec_agent_cli-0.1.0.dist-info/entry_points.txt,sha256=JdoIoefBGxdPylEMpX-KP1SS1gFWN9qHCZ75BH0mlco,51
+spec_agent_cli-0.1.0.dist-info/licenses/LICENSE,sha256=5AbBR_7xP68pz9dd83GJT3lopItANjZe5cGHfAQNRRM,1080
+spec_agent_cli-0.1.0.dist-info/RECORD,,

spec_agent_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

spec_agent_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+spec-agent = spec_agent.cli:main

spec_agent_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Spec Agent contributors
+
+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.