@1mancompany/onemancompany 0.7.30 → 0.7.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mancompany/onemancompany",
-  "version": "0.7.30",
+  "version": "0.7.31",
   "description": "The AI Operating System for One-Person Companies",
   "bin": {
     "onemancompany": "bin/cli.js"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onemancompany"
-version = "0.7.30"
+version = "0.7.31"
 description = "A one-man company simulation with pixel art visualization and LangChain AI agents"
 requires-python = ">=3.12"
 dependencies = [

package/src/onemancompany/agents/product_tools.py

@@ -562,6 +562,135 @@ async def manage_review_tool(
         return f"Error: {e}"
 
 
+# ---------------------------------------------------------------------------
+# B2: Missing CRUD + analytics tools
+# ---------------------------------------------------------------------------
+
+
+@tool
+def delete_issue_tool(product_slug: str, issue_id: str) -> str:
+    """Delete an issue and clean up all links referencing it.
+
+    Args:
+        product_slug: The product slug
+        issue_id: The issue ID to delete
+    """
+    try:
+        prod.delete_issue(product_slug, issue_id)
+        return f"Deleted issue {issue_id} from {product_slug}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def reopen_issue_tool(product_slug: str, issue_id: str) -> str:
+    """Reopen a closed issue (moves it back to backlog).
+
+    Args:
+        product_slug: The product slug
+        issue_id: The issue ID to reopen
+    """
+    try:
+        issue = prod.reopen_issue(product_slug, issue_id)
+        return f"Reopened issue {issue_id}: status={issue['status']}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def start_sprint_tool(product_slug: str, sprint_id: str) -> str:
+    """Start a sprint (set it to active). Only one sprint can be active at a time.
+
+    Args:
+        product_slug: The product slug
+        sprint_id: The sprint ID to start
+    """
+    try:
+        sprint = prod.start_sprint(product_slug, sprint_id)
+        return f"Started sprint {sprint_id}: {sprint['name']}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def delete_sprint_tool(product_slug: str, sprint_id: str) -> str:
+    """Delete a sprint. Cannot delete an active sprint — close it first.
+
+    Args:
+        product_slug: The product slug
+        sprint_id: The sprint ID to delete
+    """
+    try:
+        prod.delete_sprint(product_slug, sprint_id)
+        return f"Deleted sprint {sprint_id} from {product_slug}"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def sprint_analytics_tool(product_slug: str, sprint_id: str) -> str:
+    """Get sprint analytics: velocity (story points completed).
+
+    Args:
+        product_slug: The product slug
+        sprint_id: The sprint ID
+    """
+    try:
+        sprint = prod.load_sprint(product_slug, sprint_id)
+        if not sprint:
+            return f"Error: Sprint '{sprint_id}' not found"
+        velocity = prod.get_sprint_velocity(product_slug, sprint_id)
+        issues = prod.list_issues(product_slug, sprint=sprint_id)
+        done = sum(1 for i in issues if i.get("status") in ("done", "released"))
+        total = len(issues)
+        lines = [
+            f"Sprint: {sprint['name']} ({sprint['status']})",
+            f"Velocity: {velocity} story points",
+            f"Issues: {done}/{total} done",
+            f"Dates: {sprint['start_date']} → {sprint['end_date']}",
+        ]
+        if sprint.get("goal"):
+            lines.append(f"Goal: {sprint['goal']}")
+        return "\n".join(lines)
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
+@tool
+def version_management_tool(
+    product_slug: str,
+    action: str,
+    resolved_issue_ids: str = "",
+    bump: str = "patch",
+) -> str:
+    """Manage product versions. Actions: list, release.
+
+    Args:
+        product_slug: The product slug
+        action: 'list' to list versions, 'release' to release a new version
+        resolved_issue_ids: Comma-separated issue IDs resolved in this release (for 'release')
+        bump: Version bump type: 'patch', 'minor', or 'major' (default: 'patch')
+    """
+    try:
+        if action == "list":
+            versions = prod.list_versions(product_slug)
+            if not versions:
+                return f"No versions released for {product_slug}"
+            lines = [f"Versions for {product_slug}:"]
+            for v in versions:
+                lines.append(f"  {v['version']} — released {v.get('released_at', '?')}")
+            return "\n".join(lines)
+
+        if action == "release":
+            ids = [i.strip() for i in resolved_issue_ids.split(",") if i.strip()]
+            version = prod.release_version(product_slug, ids, bump=bump)
+            return f"Released v{version['version']} with {len(ids)} resolved issues"
+
+        return f"Error: unknown action '{action}'. Use: list, release"
+    except (ValueError, FileNotFoundError) as e:
+        return f"Error: {e}"
+
+
 # ---------------------------------------------------------------------------
 # Export
 # ---------------------------------------------------------------------------
@@ -581,4 +710,10 @@ PRODUCT_TOOLS = [
     unlink_issues_tool,
     check_blocked_issues_tool,
     manage_review_tool,
+    delete_issue_tool,
+    reopen_issue_tool,
+    start_sprint_tool,
+    delete_sprint_tool,
+    sprint_analytics_tool,
+    version_management_tool,
 ]

package/src/onemancompany/core/product.py

@@ -389,6 +389,12 @@ def update_issue(slug: str, issue_id: str, **fields) -> dict:
         data = _read_yaml(path)
         if not data:
             raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
+        # Validate status transition if status is being changed
+        new_status = fields.get("status")
+        if new_status is not None:
+            current_status = data.get("status", IssueStatus.BACKLOG.value)
+            if new_status != current_status:
+                _validate_status_transition(current_status, new_status)
         for key, value in fields.items():
             if value is not None:
                 old_value = data.get(key)
@@ -442,6 +448,53 @@ def reopen_issue(slug: str, issue_id: str) -> dict:
     return data
 
 
+def delete_issue(slug: str, issue_id: str) -> None:
+    """Delete an issue and clean up all links referencing it. Raises ValueError if not found."""
+    issue = load_issue(slug, issue_id)
+    if not issue:
+        raise ValueError(f"Issue '{issue_id}' not found in product '{slug}'")
+
+    # Clean up links from other issues pointing to this one
+    all_issues = list_issues(slug)
+    for other in all_issues:
+        if other["id"] == issue_id:
+            continue
+        links = other.get("issue_links", [])
+        if any(l["issue_id"] == issue_id for l in links):
+            _remove_link_entry(slug, other["id"], issue_id)
+
+    # Remove the issue file
+    with _get_slug_lock(slug):
+        path = _issues_dir(slug) / f"{issue_id}.yaml"
+        path.unlink(missing_ok=True)
+    mark_dirty(DirtyCategory.PRODUCTS)
+    logger.debug("Deleted issue {} from {}", issue_id, slug)
+
+
+# ---------------------------------------------------------------------------
+# Issue Status Transitions
+# ---------------------------------------------------------------------------
+
+_VALID_TRANSITIONS: dict[str, set[str]] = {
+    IssueStatus.BACKLOG.value: {IssueStatus.PLANNED.value, IssueStatus.IN_PROGRESS.value},
+    IssueStatus.PLANNED.value: {IssueStatus.IN_PROGRESS.value, IssueStatus.BACKLOG.value},
+    IssueStatus.IN_PROGRESS.value: {IssueStatus.IN_REVIEW.value, IssueStatus.DONE.value, IssueStatus.BACKLOG.value},
+    IssueStatus.IN_REVIEW.value: {IssueStatus.DONE.value, IssueStatus.IN_PROGRESS.value, IssueStatus.BACKLOG.value},
+    IssueStatus.DONE.value: {IssueStatus.RELEASED.value, IssueStatus.BACKLOG.value},
+    IssueStatus.RELEASED.value: {IssueStatus.BACKLOG.value},
+}
+
+
+def _validate_status_transition(current: str, target: str) -> None:
+    """Raise ValueError if the status transition is not allowed."""
+    allowed = _VALID_TRANSITIONS.get(current, set())
+    if target not in allowed:
+        raise ValueError(
+            f"Invalid transition: '{current}' → '{target}'. "
+            f"Allowed: {sorted(allowed)}"
+        )
+
+
 # ---------------------------------------------------------------------------
 # Issue Links
 # ---------------------------------------------------------------------------
@@ -1249,6 +1302,17 @@ def create_sprint(
     if not product:
         raise ValueError(f"Product '{slug}' not found")
 
+    # Validate dates
+    try:
+        sd = datetime.strptime(start_date, "%Y-%m-%d")
+        ed = datetime.strptime(end_date, "%Y-%m-%d")
+    except ValueError as exc:
+        raise ValueError(f"Invalid date format: {exc}") from exc
+    if ed <= sd:
+        raise ValueError(
+            f"End date '{end_date}' must be after start date '{start_date}'"
+        )
+
     sprint_id = _gen_id("sprint_")
     now = datetime.now().isoformat()
 
@@ -1320,6 +1384,25 @@ def update_sprint(slug: str, sprint_id: str, **fields) -> dict:
     return sprint
 
 
+def start_sprint(slug: str, sprint_id: str) -> dict:
+    """Start a sprint (set status to active). Raises ValueError if already active elsewhere."""
+    return update_sprint(slug, sprint_id, status=SprintStatus.ACTIVE.value)
+
+
+def delete_sprint(slug: str, sprint_id: str) -> None:
+    """Delete a sprint. Cannot delete an active sprint. Raises ValueError if not found."""
+    sprint = load_sprint(slug, sprint_id)
+    if not sprint:
+        raise ValueError(f"Sprint '{sprint_id}' not found in '{slug}'")
+    if sprint.get("status") == SprintStatus.ACTIVE.value:
+        raise ValueError(f"Cannot delete active sprint '{sprint_id}'. Close it first.")
+    with _get_slug_lock(slug):
+        path = _sprints_dir(slug) / f"{sprint_id}.yaml"
+        path.unlink(missing_ok=True)
+    mark_dirty(DirtyCategory.PRODUCTS)
+    logger.debug("Deleted sprint {} from {}", sprint_id, slug)
+
+
 def get_active_sprint(slug: str) -> dict | None:
     """Return the current active sprint for a product, or None."""
     active = list_sprints(slug, status=SprintStatus.ACTIVE.value)