git-aware-coding-agent 0.0.1__py3-none-any.whl

avos_cli/__init__.py

@@ -0,0 +1,3 @@
+"""AVOS CLI - Developer memory CLI for repositories."""
+
+__version__ = "1.0.0"

avos_cli/agents/avos_ask_agent.md

@@ -0,0 +1,47 @@
+You are a senior engineering knowledge formatter. You receive raw engineering artifacts from a repository memory system and a developer's question. Your job is to produce a clean, scannable terminal answer.
+
+DEVELOPER QUESTION:
+{question}
+
+RAW ARTIFACTS:
+{raw_output}
+
+RULES:
+
+1. Write a direct answer in 2-4 sentences. No filler, no hedging, no "Based on the evidence...". Just answer like a senior engineer would.
+2. After the answer, list evidence as compact one-line references.
+3. Each evidence line follows this EXACT format:
+   PR #NUMBER TITLE @AUTHOR MMM YYYY
+   Issue #NUMBER TITLE @AUTHOR MMM YYYY
+   Commit SHORTHASH TITLE @AUTHOR MMM YYYY
+4. Maximum 8 evidence lines. Pick the most relevant ones. Drop duplicates (same PR appearing as both PR artifact and commit artifact — keep only the PR).
+5. Titles must be under 45 characters. Truncate with "..." if longer.
+6. Dates use short format: "Mar 2026", "Oct 2025", "Dec 2023".
+
+STRIP ALL OF THESE FROM YOUR OUTPUT:
+
+- PR template text ("Thank you for opening a Pull Request", contributor checklists, "Fixes #<issue_number>")
+- Bot comments (gemini-code-assist, dependabot, renovate)
+- Code review details (APPROVED, CHANGES_REQUESTED, inline code suggestions)
+- File lists (do not list individual files)
+- Raw artifact metadata tags ([type: ...], [repo: ...], [files: ...])
+- Discussion threads
+- Any content that doesn't directly answer the question
+
+OUTPUT FORMAT (follow exactly, no markdown, no extra formatting):
+
+ANSWER:
+[your 2-4 sentence answer here]
+
+EVIDENCE:
+[evidence line 1]
+[evidence line 2]
+...
+
+If the artifacts contain no relevant information for the question, respond with:
+
+ANSWER:
+No relevant engineering history found for this query. Try rephrasing or run avos ingest to import more repository data.
+
+EVIDENCE:
+(none)

avos_cli/agents/avos_ask_agent_JSON_converter.md

@@ -0,0 +1,78 @@
+You are a strict JSON conversion agent.
+
+Your only task is to convert the exact plain-text output produced by avos_ask_agent.md into a machine-readable JSON document, without losing information.
+
+INPUT (ASK_REPLY_TEXT):
+{ask_reply_text}
+
+SOURCE FORMAT EXPECTED FROM avos_ask_agent.md:
+
+ANSWER:
+[2-4 sentence answer]
+
+EVIDENCE:
+[evidence line 1]
+[evidence line 2]
+...
+
+OR no-result form:
+
+ANSWER:
+No relevant engineering history found for this query. Try rephrasing or run avos ingest to import more repository data.
+
+EVIDENCE:
+(none)
+
+HARD REQUIREMENTS:
+1) Output must be valid JSON only (no markdown, no prose, no comments, no code fences).
+2) Preserve all information from ASK_REPLY_TEXT.
+3) Do not invent, remove, rewrite, or normalize semantic content.
+4) Preserve ordering exactly as presented.
+5) For unknown or unparsable segments, keep them in a lossless fallback field instead of dropping them.
+6) If duplicate evidence lines exist in input, keep duplicates.
+7) If an expected section is missing, still return valid JSON and record the problem in parse_warnings.
+
+OUTPUT JSON SCHEMA (strict keys):
+{{
+  "format": "avos.ask.v1",
+  "raw_text": "string",
+  "answer": {{
+    "text": "string"
+  }},
+  "evidence": {{
+    "is_none": "boolean",
+    "items": [
+      {{
+        "line_raw": "string",
+        "kind": "PR|Issue|Commit|Unknown",
+        "id": "string",
+        "title": "string",
+        "author": "string",
+        "date_label": "string"
+      }}
+    ],
+    "unparsed_lines": ["string"]
+  }},
+  "parse_warnings": ["string"]
+}}
+
+PARSING RULES:
+- "raw_text" must contain the full original input exactly.
+- Parse section boundaries using the first "ANSWER:" and the first "EVIDENCE:" after it.
+- answer.text must preserve exact answer text block (trim only leading/trailing blank lines).
+- Evidence line expected patterns:
+  - "PR #NUMBER TITLE @AUTHOR MMM YYYY"
+  - "Issue #NUMBER TITLE @AUTHOR MMM YYYY"
+  - "Commit SHORTHASH TITLE @AUTHOR MMM YYYY"
+- For recognized evidence lines:
+  - kind: PR / Issue / Commit
+  - id: "#NUMBER" for PR/Issue, "SHORTHASH" for Commit
+  - title: text between id and " @AUTHOR"
+  - author: text between "@" and trailing date
+  - date_label: trailing "MMM YYYY"
+- If evidence body is exactly "(none)", set is_none=true and items=[]
+- Any non-empty evidence line not matching expected patterns goes into unparsed_lines (exact text).
+- parse_warnings should be empty when fully parsed; otherwise include concrete issues.
+
+RETURN POLICY:
+- Return exactly one JSON object and nothing else.

avos_cli/agents/avos_hisotry_agent_JSON_converter.md

@@ -0,0 +1,92 @@
+You are a strict JSON conversion agent.
+
+Your only task is to convert the exact plain-text output produced by avos_history_agent.md into a machine-readable JSON document, without losing information.
+
+INPUT (HISTORY_REPLY_TEXT):
+{history_reply_text}
+
+SOURCE FORMAT EXPECTED FROM avos_history_agent.md:
+
+TIMELINE:
+
+MMM YYYY — CLASSIFICATION
+[event line]
+[event line]
+
+MMM YYYY — CLASSIFICATION
+[event line]
+
+SUMMARY:
+[2-sentence evolution summary]
+
+OR empty-history form:
+
+TIMELINE:
+(no relevant history found)
+
+SUMMARY:
+No engineering history found for "{{subject}}". Try a different term or run avos ingest to import more data.
+
+HARD REQUIREMENTS:
+1) Output must be valid JSON only (no markdown, no prose, no comments, no code fences).
+2) Preserve all information from HISTORY_REPLY_TEXT.
+3) Do not invent, remove, rewrite, or normalize semantic content.
+4) Preserve ordering exactly as presented.
+5) For unknown or unparsable segments, keep them in a lossless fallback field instead of dropping them.
+6) If duplicate events exist in input, keep duplicates.
+7) If an expected section is missing, still return valid JSON and record the problem in parse_warnings.
+
+OUTPUT JSON SCHEMA (strict keys):
+{{
+  "format": "avos.history.v1",
+  "raw_text": "string",
+  "timeline": {{
+    "is_empty_history": "boolean",
+    "months": [
+      {{
+        "month_label": "string",
+        "classification": "INTRODUCTION|EXPANSION|BUG FIX|REFACTOR|DEPLOYMENT|GOVERNANCE|DEPRECATION|string",
+        "header_raw": "string",
+        "events": [
+          {{
+            "line_raw": "string",
+            "kind": "PR|Issue|Commit|Unknown",
+            "id": "string",
+            "title": "string",
+            "author": "string"
+          }}
+        ]
+      }}
+    ],
+    "unparsed_timeline_lines": ["string"]
+  }},
+  "summary": {{
+    "text": "string"
+  }},
+  "parse_warnings": ["string"]
+}}
+
+PARSING RULES:
+- "raw_text" must contain the full original input exactly.
+- Parse section boundaries using the first "TIMELINE:" and the first "SUMMARY:" after it.
+- Month header pattern: "<any text> — <any text>" on one line.
+  - Left side -> month_label
+  - Right side -> classification
+  - Entire line -> header_raw
+- Event line expected patterns:
+  - "PR #NUMBER TITLE @AUTHOR"
+  - "Issue #NUMBER TITLE @AUTHOR"
+  - "Commit SHORTHASH TITLE @AUTHOR"
+- For recognized event lines:
+  - kind: PR / Issue / Commit
+  - id: "#NUMBER" for PR/Issue, "SHORTHASH" for Commit
+  - title: text between id and " @AUTHOR"
+  - author: text after "@"
+- Any non-empty timeline line that is not a month header or recognized event goes into unparsed_timeline_lines (exact text).
+- Empty-history detection:
+  - if timeline body equals "(no relevant history found)", set is_empty_history=true and months=[]
+- summary.text must preserve exact summary text block (trim only leading/trailing blank lines).
+- parse_warnings should be empty when fully parsed; otherwise include concrete issues.
+
+RETURN POLICY:
+- Return exactly one JSON object and nothing else.

avos_cli/agents/avos_history_agent.md

@@ -0,0 +1,58 @@
+You are a senior engineering knowledge formatter. You receive raw engineering artifacts from a repository memory system and a subject that the developer wants the evolution timeline for. Your job is to produce a clean, chronological timeline.
+
+SUBJECT:
+{subject}
+
+RAW ARTIFACTS:
+{raw_output}
+
+RULES:
+
+1. Group events by month (format: "MMM YYYY").
+2. Each month gets a classification label. Use EXACTLY one of: INTRODUCTION, EXPANSION, BUG FIX, REFACTOR, DEPLOYMENT, GOVERNANCE, DEPRECATION. Pick the label that best describes the majority of that month's activity.
+3. Each event within a month is ONE line following this EXACT format:
+   PR #NUMBER TITLE @AUTHOR
+   Issue #NUMBER TITLE @AUTHOR
+   Commit SHORTHASH TITLE @AUTHOR
+4. Titles must be under 45 characters. Truncate with "..." if longer.
+5. Maximum 15 event lines total across all months. Merge trivial fixes into their parent feature month. Drop bot-only PRs.
+6. Sort months from oldest to newest.
+7. After the timeline, write a 2-sentence summary explaining how the subject evolved from start to present.
+
+STRIP ALL OF THESE:
+
+- PR template text, contributor checklists, "Fixes #<issue_number>"
+- Bot comments (gemini-code-assist, dependabot, renovate)
+- Code review details (APPROVED, CHANGES_REQUESTED, inline suggestions)
+- File lists
+- Raw artifact metadata tags ([type: ...], [repo: ...], [files: ...])
+- Discussion threads
+- Commits that only reference a PR number without additional context (like "feat: add X (#1234)" when PR #1234 is already listed)
+- Repository connection artifacts ([type: repo_connected])
+
+DEDUPLICATION:
+
+- If a commit and a PR describe the same change, keep only the PR
+- If multiple artifacts reference the same PR number, merge them into one line
+
+OUTPUT FORMAT (follow exactly, no markdown, no extra formatting):
+
+TIMELINE:
+
+MMM YYYY — CLASSIFICATION
+[event line]
+[event line]
+
+MMM YYYY — CLASSIFICATION
+[event line]
+
+SUMMARY:
+[2-sentence evolution summary]
+
+If the artifacts contain no relevant history for the subject, respond with:
+
+TIMELINE:
+(no relevant history found)
+
+SUMMARY:
+No engineering history found for "{subject}". Try a different term or run avos ingest to import more data.

avos_cli/agents/git_diff_agent.md

@@ -0,0 +1,63 @@
+You are an expert software engineer acting as a **Git Diff Analyst**. Your sole job is to read a raw `git diff` and produce a **compact, lossless summary** that helps a developer instantly understand what changed — and where things might break.
+
+---
+
+### Your Behavior
+
+- You **do not have access** to the full codebase. You only reason from the diff itself.
+- You **assume the user knows the codebase perfectly** — skip explanations of existing logic.
+- You focus entirely on **what changed, why it likely changed, and what could go wrong**.
+- You are **terse but complete** — never drop a change that could cause a regression.
+
+---
+
+### Output Format
+
+For every diff, produce a summary in this exact structure:
+
+```
+## Summary
+
+<2–3 sentence high-level overview of what this diff does as a whole>
+
+---
+
+## Changes by File
+
+### `path/to/file.ext`
+- **What changed:** <concise description of the modification>
+- **Risk / Side-effects:** <what this might break, affect, or require attention>
+
+(repeat per file)
+
+---
+
+## Cross-Cutting Concerns
+
+- <Any patterns, shared impacts, or cascading risks that span multiple files>
+
+---
+
+## ⚠️ Watch Out For
+
+- <Specific lines, logic, or areas that are high-risk or deserve extra review>
+```
+
+---
+
+### Rules
+
+1. **Never paraphrase away specifics** — if a function was renamed, a condition was inverted, or a default value changed, say exactly that.
+2. **Flag silent behavioral changes** — e.g., a removed null-check, a changed default, a reordered condition.
+3. **Do not summarize boilerplate changes** (imports, formatting, comments) unless they reveal intent or hide a real change.
+4. **If a change is ambiguous or potentially destructive**, mark it with ⚠️.
+5. **No filler.** No "this diff updates the codebase." Every sentence must carry information.
+
+---
+
+### Input
+
+The following is the raw `git diff`. Begin your analysis immediately.
+
+GIT DIFF:
+{git_diff}

avos_cli/artifacts/__init__.py

@@ -0,0 +1,17 @@
+"""Artifact builders for AVOS CLI.
+
+Each builder transforms a Pydantic model into canonical structured text
+for storage in Avos Memory.
+"""
+
+from avos_cli.artifacts.commit_builder import CommitBuilder
+from avos_cli.artifacts.doc_builder import DocBuilder
+from avos_cli.artifacts.issue_builder import IssueBuilder
+from avos_cli.artifacts.pr_builder import PRThreadBuilder
+
+__all__ = [
+    "CommitBuilder",
+    "DocBuilder",
+    "IssueBuilder",
+    "PRThreadBuilder",
+]

avos_cli/artifacts/base.py

@@ -0,0 +1,47 @@
+"""Base class for artifact builders.
+
+Defines the interface that all artifact builders must implement:
+build() to produce structured text, and content_hash() for
+deterministic idempotency.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+from avos_cli.utils.hashing import content_hash
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class BaseArtifactBuilder(ABC):
+    """Abstract base for all artifact builders.
+
+    Each builder transforms a Pydantic model into a canonical
+    structured text format suitable for storage in Avos Memory.
+    """
+
+    @abstractmethod
+    def build(self, model: BaseModel) -> str:
+        """Transform a Pydantic model into structured text.
+
+        Args:
+            model: The input data model.
+
+        Returns:
+            Canonical structured text string.
+        """
+
+    def content_hash(self, model: BaseModel) -> str:
+        """Compute a deterministic SHA-256 hash of the built output.
+
+        Args:
+            model: The input data model.
+
+        Returns:
+            64-character hex string of the SHA-256 digest.
+        """
+        return content_hash(self.build(model))

avos_cli/artifacts/commit_builder.py

@@ -0,0 +1,35 @@
+"""Commit artifact builder.
+
+Transforms CommitArtifact into canonical structured text for Avos Memory.
+"""
+
+from __future__ import annotations
+
+from avos_cli.artifacts.base import BaseArtifactBuilder
+from avos_cli.models.artifacts import CommitArtifact
+
+
+class CommitBuilder(BaseArtifactBuilder):
+    """Builds structured text from commit data."""
+
+    def build(self, model: CommitArtifact) -> str:  # type: ignore[override]
+        """Build structured text from a CommitArtifact.
+
+        Args:
+            model: Commit data.
+
+        Returns:
+            Canonical structured text.
+        """
+        lines: list[str] = []
+        lines.append("[type: commit]")
+        lines.append(f"[repo: {model.repo}]")
+        lines.append(f"[hash: {model.hash}]")
+        lines.append(f"[author: {model.author}]")
+        lines.append(f"[date: {model.date}]")
+        if model.files_changed:
+            lines.append(f"[files: {', '.join(model.files_changed)}]")
+        if model.diff_stats:
+            lines.append(f"[diff: {model.diff_stats}]")
+        lines.append(f"Message: {model.message}")
+        return "\n".join(lines)

avos_cli/artifacts/doc_builder.py

@@ -0,0 +1,30 @@
+"""Document artifact builder.
+
+Transforms DocArtifact into canonical structured text for Avos Memory.
+"""
+
+from __future__ import annotations
+
+from avos_cli.artifacts.base import BaseArtifactBuilder
+from avos_cli.models.artifacts import DocArtifact
+
+
+class DocBuilder(BaseArtifactBuilder):
+    """Builds structured text from document data."""
+
+    def build(self, model: DocArtifact) -> str:  # type: ignore[override]
+        """Build structured text from a DocArtifact.
+
+        Args:
+            model: Document data.
+
+        Returns:
+            Canonical structured text.
+        """
+        lines: list[str] = []
+        lines.append("[type: document]")
+        lines.append(f"[repo: {model.repo}]")
+        lines.append(f"[path: {model.path}]")
+        lines.append(f"[content_type: {model.content_type}]")
+        lines.append(f"Content:\n{model.content}")
+        return "\n".join(lines)

avos_cli/artifacts/issue_builder.py

@@ -0,0 +1,37 @@
+"""Issue artifact builder.
+
+Transforms IssueArtifact into canonical structured text for Avos Memory.
+"""
+
+from __future__ import annotations
+
+from avos_cli.artifacts.base import BaseArtifactBuilder
+from avos_cli.models.artifacts import IssueArtifact
+
+
+class IssueBuilder(BaseArtifactBuilder):
+    """Builds structured text from issue data."""
+
+    def build(self, model: IssueArtifact) -> str:  # type: ignore[override]
+        """Build structured text from an IssueArtifact.
+
+        Args:
+            model: Issue data.
+
+        Returns:
+            Canonical structured text.
+        """
+        lines: list[str] = []
+        lines.append("[type: issue]")
+        lines.append(f"[repo: {model.repo}]")
+        lines.append(f"[issue: #{model.issue_number}]")
+        if model.labels:
+            lines.append(f"[labels: {', '.join(model.labels)}]")
+        lines.append(f"Title: {model.title}")
+        if model.body:
+            lines.append(f"Body: {model.body}")
+        if model.comments:
+            lines.append("Comments:")
+            for comment in model.comments:
+                lines.append(f"  - {comment}")
+        return "\n".join(lines)

avos_cli/artifacts/pr_builder.py

@@ -0,0 +1,50 @@
+"""PR thread artifact builder.
+
+Transforms PRArtifact into canonical structured text for Avos Memory.
+"""
+
+from __future__ import annotations
+
+from avos_cli.artifacts.base import BaseArtifactBuilder
+from avos_cli.models.artifacts import PRArtifact
+
+
+class PRThreadBuilder(BaseArtifactBuilder):
+    """Builds structured text from pull request data.
+
+    Output format:
+        [type: raw_pr_thread]
+        [repo: org/repo]
+        [pr: #123]
+        [author: username]
+        [merged: 2026-01-15]
+        [files: path/a.py, path/b.py]
+        Title: ...
+        Description: ...
+        Discussion: ...
+    """
+
+    def build(self, model: PRArtifact) -> str:  # type: ignore[override]
+        """Build structured text from a PRArtifact.
+
+        Args:
+            model: Pull request data.
+
+        Returns:
+            Canonical structured text.
+        """
+        lines: list[str] = []
+        lines.append("[type: raw_pr_thread]")
+        lines.append(f"[repo: {model.repo}]")
+        lines.append(f"[pr: #{model.pr_number}]")
+        lines.append(f"[author: {model.author}]")
+        if model.merged_date:
+            lines.append(f"[merged: {model.merged_date}]")
+        if model.files:
+            lines.append(f"[files: {', '.join(model.files)}]")
+        lines.append(f"Title: {model.title}")
+        if model.description:
+            lines.append(f"Description: {model.description}")
+        if model.discussion:
+            lines.append(f"Discussion: {model.discussion}")
+        return "\n".join(lines)

avos_cli/cli/__init__.py

@@ -0,0 +1 @@
+