gobby 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

gobby/storage/tasks/_crud.py

@@ -276,7 +276,7 @@ def update_task(
     agent_name: Any = UNSET,
     reference_doc: Any = UNSET,
     is_expanded: Any = UNSET,
-    is_tdd_applied: Any = UNSET,
+    expansion_status: Any = UNSET,
     validation_override_reason: Any = UNSET,
     requires_user_review: Any = UNSET,
 ) -> bool:
@@ -412,9 +412,9 @@ def update_task(
     if is_expanded is not UNSET:
         updates.append("is_expanded = ?")
         params.append(1 if is_expanded else 0)
-    if is_tdd_applied is not UNSET:
-        updates.append("is_tdd_applied = ?")
-        params.append(1 if is_tdd_applied else 0)
+    if expansion_status is not UNSET:
+        updates.append("expansion_status = ?")
+        params.append(expansion_status)
     if validation_override_reason is not UNSET:
         updates.append("validation_override_reason = ?")
         params.append(validation_override_reason)

gobby/storage/tasks/_lifecycle.py

@@ -274,20 +274,39 @@ def unlink_commit(
     return False
 
 
-def delete_task(db: DatabaseProtocol, task_id: str, cascade: bool = False) -> bool:
-    """Delete a task. If cascade is True, delete children recursively.
+def delete_task(
+    db: DatabaseProtocol,
+    task_id: str,
+    cascade: bool = False,
+    unlink: bool = False,
+    _visited: set[str] | None = None,
+) -> bool:
+    """Delete a task.
 
     Args:
         db: Database protocol instance
         task_id: The task ID to delete
-        cascade: If True, delete children recursively (default: False)
+        cascade: If True, delete children AND dependent tasks recursively
+        unlink: If True, remove dependency links but preserve dependent tasks
+                (ignored if cascade=True)
+        _visited: Internal parameter to track visited tasks and prevent infinite recursion
+                  when a parent task depends on its children (circular dependency)
 
     Returns:
         True if task was deleted, False if task not found.
 
     Raises:
-        ValueError: If task has children and cascade is False.
+        ValueError: If task has children or dependents and neither cascade nor unlink is True.
     """
+    # Initialize visited set on first call to prevent infinite recursion
+    if _visited is None:
+        _visited = set()
+
+    # Skip if already being deleted (prevents cycles when parent depends on children)
+    if task_id in _visited:
+        return True
+    _visited.add(task_id)
+
     # Check if task exists first
     existing = db.fetchone("SELECT 1 FROM tasks WHERE id = ?", (task_id,))
     if not existing:
@@ -299,12 +318,43 @@ def delete_task(db: DatabaseProtocol, task_id: str, cascade: bool = False) -> bo
         if row:
             raise ValueError(f"Task {task_id} has children. Use cascade=True to delete.")
 
+    if not cascade and not unlink:
+        # Check for dependents (tasks that depend on this task)
+        dependent_rows = db.fetchall(
+            """SELECT t.id, t.seq_num, t.title
+               FROM tasks t
+               JOIN task_dependencies d ON d.task_id = t.id
+               WHERE d.depends_on = ? AND d.dep_type = 'blocks'""",
+            (task_id,),
+        )
+        if dependent_rows:
+            refs = [f"#{r['seq_num']}" for r in dependent_rows[:5] if r["seq_num"]]
+            refs_str = ", ".join(refs) if refs else str(len(dependent_rows)) + " task(s)"
+            if len(dependent_rows) > 5:
+                refs_str += f" and {len(dependent_rows) - 5} more"
+            raise ValueError(
+                f"Task {task_id} has {len(dependent_rows)} dependent task(s): {refs_str}. "
+                f"Use cascade=True to delete dependents, or unlink=True to preserve them."
+            )
+
     if cascade:
-        # Recursive delete
-        # Find all children
+        # Recursive delete children
         children = db.fetchall("SELECT id FROM tasks WHERE parent_task_id = ?", (task_id,))
         for child in children:
-            delete_task(db, child["id"], cascade=True)
+            delete_task(db, child["id"], cascade=True, _visited=_visited)
+
+        # Delete tasks that depend on this task (only 'blocks' dependencies)
+        dependents = db.fetchall(
+            """SELECT t.id FROM tasks t
+               JOIN task_dependencies d ON d.task_id = t.id
+               WHERE d.depends_on = ? AND d.dep_type = 'blocks'""",
+            (task_id,),
+        )
+        for dep in dependents:
+            delete_task(db, dep["id"], cascade=True, _visited=_visited)
+
+    # Note: if unlink=True, dependency links are removed by ON DELETE CASCADE
+    # when the task is deleted - no explicit action needed
 
     with db.transaction() as conn:
         conn.execute("DELETE FROM tasks WHERE id = ?", (task_id,))

gobby/storage/tasks/_manager.py

@@ -306,7 +306,7 @@ class LocalTaskManager:
         agent_name: str | None | Any = UNSET,
         reference_doc: str | None | Any = UNSET,
         is_expanded: bool | None | Any = UNSET,
-        is_tdd_applied: bool | None | Any = UNSET,
+        expansion_status: str | None | Any = UNSET,
         validation_override_reason: str | None | Any = UNSET,
         requires_user_review: bool | None | Any = UNSET,
     ) -> Task:
@@ -344,7 +344,7 @@ class LocalTaskManager:
             agent_name=agent_name,
             reference_doc=reference_doc,
             is_expanded=is_expanded,
-            is_tdd_applied=is_tdd_applied,
+            expansion_status=expansion_status,
             validation_override_reason=validation_override_reason,
             requires_user_review=requires_user_review,
         )
@@ -462,13 +462,22 @@ class LocalTaskManager:
             self._notify_listeners()
         return self.get_task(task_id)
 
-    def delete_task(self, task_id: str, cascade: bool = False) -> bool:
-        """Delete a task. If cascade is True, delete children recursively.
+    def delete_task(self, task_id: str, cascade: bool = False, unlink: bool = False) -> bool:
+        """Delete a task.
+
+        Args:
+            task_id: The task ID to delete
+            cascade: If True, delete children AND dependent tasks recursively
+            unlink: If True, remove dependency links but preserve dependent tasks
+                    (ignored if cascade=True)
 
         Returns:
             True if task was deleted, False if task not found.
+
+        Raises:
+            ValueError: If task has children or dependents and neither cascade nor unlink is True.
         """
-        result = _delete_task(self.db, task_id, cascade)
+        result = _delete_task(self.db, task_id, cascade=cascade, unlink=unlink)
         if result:
             self._notify_listeners()
         return result

gobby/storage/tasks/_models.py

@@ -133,7 +133,8 @@ class Task:
     reference_doc: str | None = None  # Path to source specification document
     # Processing flags for idempotent operations
     is_expanded: bool = False  # Subtasks have been created
-    is_tdd_applied: bool = False  # TDD pairs have been generated
+    # Skill-based expansion status (for new /gobby-expand flow)
+    expansion_status: Literal["none", "pending", "completed"] = "none"
     # Review status fields (HITL support)
     requires_user_review: bool = False  # Task requires user sign-off before closing
     accepted_by_user: bool = False  # Set True when user moves review → closed
@@ -213,7 +214,11 @@ class Task:
             agent_name=row["agent_name"] if "agent_name" in keys else None,
             reference_doc=row["reference_doc"] if "reference_doc" in keys else None,
             is_expanded=bool(row["is_expanded"]) if "is_expanded" in keys else False,
-            is_tdd_applied=bool(row["is_tdd_applied"]) if "is_tdd_applied" in keys else False,
+            expansion_status=(
+                row["expansion_status"]
+                if "expansion_status" in keys and row["expansion_status"]
+                else "none"
+            ),
             requires_user_review=(
                 bool(row["requires_user_review"]) if "requires_user_review" in keys else False
             ),
@@ -268,7 +273,7 @@ class Task:
             "agent_name": self.agent_name,
             "reference_doc": self.reference_doc,
             "is_expanded": self.is_expanded,
-            "is_tdd_applied": self.is_tdd_applied,
+            "expansion_status": self.expansion_status,
             "requires_user_review": self.requires_user_review,
             "accepted_by_user": self.accepted_by_user,
             "id": self.id,  # UUID at end for backwards compat

gobby/sync/memories.py

@@ -16,8 +16,10 @@ Classes:
 import asyncio
 import json
 import logging
+import os
 import time
 from pathlib import Path
+from typing import Any
 
 __all__ = [
     "MemoryBackupManager",
@@ -27,7 +29,7 @@ __all__ = [
 # TODO: Rename MemorySyncConfig to MemoryBackupConfig in gobby.config.persistence
 # for consistency with MemoryBackupManager naming. Keeping current name for now
 # to minimize breaking changes across the codebase.
-from gobby.config.app import MemorySyncConfig
+from gobby.config.persistence import MemorySyncConfig
 from gobby.memory.manager import MemoryManager
 from gobby.storage.database import DatabaseProtocol
 
@@ -251,19 +253,52 @@ class MemoryBackupManager:
 
         return count
 
+    def _sanitize_content(self, content: str) -> str:
+        """Replace user home directories with ~ for privacy.
+
+        Prevents absolute user paths like /Users/josh from being
+        committed to version control.
+        """
+        home = os.path.expanduser("~")
+        return content.replace(home, "~")
+
+    def _deduplicate_memories(self, memories: list[Any]) -> list[Any]:
+        """Deduplicate memories by normalized content, keeping earliest.
+
+        Args:
+            memories: List of memory objects
+
+        Returns:
+            List of unique memories (by content), keeping the earliest created_at
+        """
+        seen_content: dict[str, Any] = {}  # normalized_content -> memory
+        for memory in memories:
+            normalized = memory.content.strip()
+            if normalized not in seen_content:
+                seen_content[normalized] = memory
+            else:
+                # Keep the one with earlier created_at
+                existing = seen_content[normalized]
+                if memory.created_at < existing.created_at:
+                    seen_content[normalized] = memory
+        return list(seen_content.values())
+
     def _export_memories_sync(self, file_path: Path) -> int:
-        """Export memories to JSONL file (sync)."""
+        """Export memories to JSONL file (sync) with deduplication and path sanitization."""
         if not self.memory_manager:
             return 0
 
         try:
             memories = self.memory_manager.list_memories()
 
+            # Deduplicate by content before export
+            unique_memories = self._deduplicate_memories(memories)
+
             with open(file_path, "w", encoding="utf-8") as f:
-                for memory in memories:
+                for memory in unique_memories:
                     data = {
                         "id": memory.id,
-                        "content": memory.content,
+                        "content": self._sanitize_content(memory.content),
                         "type": memory.memory_type,
                         "importance": memory.importance,
                         "tags": memory.tags,
@@ -274,7 +309,7 @@ class MemoryBackupManager:
                     }
                     f.write(json.dumps(data, ensure_ascii=False) + "\n")
 
-            return len(memories)
+            return len(unique_memories)
         except Exception as e:
             logger.error(f"Failed to export memories: {e}")
             return 0

gobby/sync/tasks.py

@@ -15,6 +15,56 @@ from gobby.utils.git import normalize_commit_sha
 logger = logging.getLogger(__name__)
 
 
+def _parse_timestamp(ts: str) -> datetime:
+    """Parse ISO 8601 timestamp string to datetime.
+
+    Handles both Z suffix and +HH:MM offset formats for compatibility
+    with existing data that may use either format.
+
+    Args:
+        ts: ISO 8601 timestamp string (e.g., "2026-01-25T01:43:54Z" or
+            "2026-01-25T01:43:54.123456+00:00")
+
+    Returns:
+        Timezone-aware datetime object in UTC
+    """
+    # Handle Z suffix for fromisoformat compatibility
+    parse_ts = ts[:-1] + "+00:00" if ts.endswith("Z") else ts
+    dt = datetime.fromisoformat(parse_ts)
+
+    # Ensure timezone is UTC
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=UTC)
+    return dt.astimezone(UTC)
+
+
+def _normalize_timestamp(ts: str | None) -> str | None:
+    """Normalize timestamp to consistent RFC 3339 format.
+
+    Ensures all timestamps have:
+    - Microsecond precision (.ffffff)
+    - UTC timezone as +00:00 suffix
+
+    Args:
+        ts: ISO 8601 timestamp string
+
+    Returns:
+        Timestamp in format YYYY-MM-DDTHH:MM:SS.ffffff+00:00, or None if input was None
+    """
+    if ts is None:
+        return None
+
+    try:
+        dt = _parse_timestamp(ts)
+    except ValueError:
+        # If parsing fails, return original (shouldn't happen with valid ISO 8601)
+        return ts
+
+    # Format with consistent microseconds and +00:00 suffix
+    base = dt.strftime("%Y-%m-%dT%H:%M:%S")
+    return f"{base}.{dt.microsecond:06d}+00:00"
+
+
 class TaskSyncManager:
     """
     Manages synchronization of tasks to the filesystem (JSONL) for Git versioning.
@@ -137,8 +187,9 @@ class TaskSyncManager:
                     "title": task.title,
                     "description": task.description,
                     "status": task.status,
-                    "created_at": task.created_at,
-                    "updated_at": task.updated_at,
+                    # Normalize timestamps to ensure RFC 3339 compliance (with timezone)
+                    "created_at": _normalize_timestamp(task.created_at),
+                    "updated_at": _normalize_timestamp(task.updated_at),
                     "project_id": task.project_id,
                     "parent_id": task.parent_task_id,
                     "deps_on": sorted(deps_map.get(task.id, [])),  # Sort deps for stability
@@ -157,8 +208,8 @@ class TaskSyncManager:
                         if task.validation_status
                         else None
                     ),
-                    # Escalation fields
-                    "escalated_at": task.escalated_at,
+                    # Escalation fields (normalize timestamps)
+                    "escalated_at": _normalize_timestamp(task.escalated_at),
                     "escalation_reason": task.escalation_reason,
                     # Human-friendly IDs (preserve across sync)
                     "seq_num": task.seq_num,
@@ -248,7 +299,21 @@ class TaskSyncManager:
 
                         data = json.loads(line)
                         task_id = data["id"]
-                        updated_at_file = datetime.fromisoformat(data["updated_at"])
+                        # Guard against None/missing updated_at in JSONL
+                        raw_updated_at = data.get("updated_at")
+                        if raw_updated_at is None:
+                            # Skip tasks without timestamps or use a safe default
+                            logger.warning(f"Task {task_id} missing updated_at, skipping")
+                            skipped_count += 1
+                            continue
+                        try:
+                            updated_at_file = _parse_timestamp(raw_updated_at)
+                        except ValueError as e:
+                            logger.warning(
+                                f"Task {task_id}: malformed timestamp '{raw_updated_at}': {e}, skipping"
+                            )
+                            skipped_count += 1
+                            continue
 
                         # Check if task exists (also fetch seq_num/path_cache to preserve)
                         existing_row = self.db.fetchone(
@@ -263,7 +328,19 @@ class TaskSyncManager:
                             should_update = True
                             imported_count += 1
                         else:
-                            updated_at_db = datetime.fromisoformat(existing_row["updated_at"])
+                            # Handle NULL timestamps in DB (treat as infinitely old)
+                            db_updated_at = existing_row["updated_at"]
+                            if db_updated_at is None:
+                                updated_at_db = datetime.min.replace(tzinfo=UTC)
+                            else:
+                                try:
+                                    updated_at_db = _parse_timestamp(db_updated_at)
+                                except ValueError as e:
+                                    logger.warning(
+                                        f"Task {task_id}: failed to parse DB timestamp "
+                                        f"'{db_updated_at}': {e}, treating as old"
+                                    )
+                                    updated_at_db = datetime.min.replace(tzinfo=UTC)
                             existing_seq_num = existing_row["seq_num"]
                             existing_path_cache = existing_row["path_cache"]
                             if updated_at_file > updated_at_db:

gobby/tasks/__init__.py

@@ -2,7 +2,6 @@
 Task management components.
 """
 
-from gobby.tasks.expansion import TaskExpander
 from gobby.tasks.validation import TaskValidator, ValidationResult
 
-__all__ = ["TaskExpander", "TaskValidator", "ValidationResult"]
+__all__ = ["TaskValidator", "ValidationResult"]

gobby/tasks/external_validator.py

@@ -14,7 +14,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from gobby.config.app import TaskValidationConfig
+from gobby.config.tasks import TaskValidationConfig
 from gobby.llm import LLMService
 from gobby.prompts import PromptLoader
 from gobby.tasks.commits import (

gobby/tasks/validation.py

@@ -20,11 +20,9 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal
 
-from gobby.config.app import TaskValidationConfig
-from gobby.config.tasks import PatternCriteriaConfig
+from gobby.config.tasks import TaskValidationConfig
 from gobby.llm import LLMService
 from gobby.prompts import PromptLoader
-from gobby.tasks.criteria import PatternCriteriaInjector
 from gobby.utils.json_helpers import extract_json_object
 
 logger = logging.getLogger(__name__)
@@ -591,14 +589,8 @@ class TaskValidator:
                 category_section += "\n"
 
         # Build prompt using PromptLoader or legacy config
-        if self.config.prompt:
-            # Legacy inline config (deprecated)
-            prompt = self.config.prompt
-            if file_context:
-                prompt += f"\nFile Context:\n{file_context[:50000]}\n"
-        else:
-            # Use PromptLoader
-            prompt_path = self.config.prompt_path or "validation/validate"
+        if self.config.prompt_path:
+            prompt_path = self.config.prompt_path
             template_context = {
                 "title": title,
                 "category_section": category_section,
@@ -613,6 +605,18 @@ class TaskValidator:
                 prompt = DEFAULT_VALIDATE_PROMPT.format(**template_context)
                 if file_context:
                     prompt += f"\nFile Context:\n{file_context[:50000]}\n"
+        else:
+            # Default behavior
+            template_context = {
+                "title": title,
+                "category_section": category_section,
+                "criteria_text": criteria_text,
+                "changes_section": changes_section,
+                "file_context": file_context[:50000] if file_context else "",
+            }
+            prompt = DEFAULT_VALIDATE_PROMPT.format(**template_context)
+            if file_context:
+                prompt += f"\nFile Context:\n{file_context[:50000]}\n"
 
         try:
             provider = self.llm_service.get_provider(self.config.provider)
@@ -655,14 +659,10 @@ class TaskValidator:
         """
         Generate validation criteria from task title and description.
 
-        When labels are provided (e.g., 'tdd', 'strangler-fig', 'refactoring'),
-        pattern-specific criteria from PatternCriteriaConfig are appended to
-        the LLM-generated criteria.
-
         Args:
             title: Task title
             description: Task description (optional)
-            labels: Task labels for pattern criteria injection (optional)
+            labels: Task labels (currently unused, kept for API compatibility)
 
         Returns:
             Generated validation criteria string, or None if generation fails
@@ -676,17 +676,13 @@ class TaskValidator:
             "description": description or "(no description)",
         }
 
-        if self.config.criteria_prompt:
-            # Legacy inline config (deprecated)
-            prompt = self.config.criteria_prompt.format(**template_context)
-        else:
-            # Use PromptLoader
-            prompt_path = self.config.criteria_prompt_path or "validation/criteria"
-            try:
-                prompt = self._loader.render(prompt_path, template_context)
-            except FileNotFoundError:
-                logger.debug(f"Prompt template '{prompt_path}' not found, using fallback")
-                prompt = DEFAULT_CRITERIA_PROMPT.format(**template_context)
+        # Use PromptLoader
+        prompt_path = self.config.criteria_prompt_path or "validation/criteria"
+        try:
+            prompt = self._loader.render(prompt_path, template_context)
+        except FileNotFoundError:
+            logger.debug(f"Prompt template '{prompt_path}' not found, using fallback")
+            prompt = DEFAULT_CRITERIA_PROMPT.format(**template_context)
 
         try:
             provider = self.llm_service.get_provider(self.config.provider)
@@ -695,18 +691,33 @@ class TaskValidator:
                 system_prompt=self.config.criteria_system_prompt,
                 model=self.config.model,
             )
-            llm_criteria = response.strip()
+            if not response or not response.strip():
+                logger.warning("Empty LLM response for criteria generation")
+                return None
+
+            llm_result = response.strip()
 
-            # Inject pattern-specific criteria if labels are provided
+            # Inject pattern criteria if labels provided
             if labels:
-                pattern_config = PatternCriteriaConfig()
-                injector = PatternCriteriaInjector(pattern_config=pattern_config)
-                pattern_criteria = injector.inject_for_labels(labels=labels)
+                try:
+                    from gobby.config.tasks import PatternCriteriaConfig
+
+                    pattern_config = PatternCriteriaConfig()
+                    pattern_sections = []
+
+                    for label in labels:
+                        if label in pattern_config.patterns:
+                            criteria_list = pattern_config.patterns[label]
+                            section = f"\n\n## {label.title().replace('-', ' ')} Pattern Criteria\n"
+                            section += "\n".join(f"- [ ] {c}" for c in criteria_list)
+                            pattern_sections.append(section)
 
-                if pattern_criteria:
-                    llm_criteria = f"{llm_criteria}\n\n{pattern_criteria}"
+                    if pattern_sections:
+                        llm_result += "".join(pattern_sections)
+                except Exception as e:
+                    logger.warning(f"Failed to inject pattern criteria: {e}")
 
-            return llm_criteria
+            return llm_result
         except Exception as e:
             logger.error(f"Failed to generate validation criteria: {e}")
             return None