@mc1global/opencode-jarvis 0.13.1 → 0.14.1

package/src/domain/user_story_chat/README.md

@@ -1,83 +0,0 @@
-🤖 Using: llama3.2:3b (temp=0.3)
-✅ Completed in 20.2s
-# User Story Chat Domain
-
-## Overview
-
-The User Story Chat domain is responsible for managing the conversation between the Product Owner and the user to extract a structured user story. This domain provides a bounded context that defines the rules and behavior of the interview process.
-
-## Architecture
-
-The architecture consists of three layers:
-
-1. **Domain Layer**: This layer contains the core business logic, including entities (e.g., `ChatMessage`, `ChatSession`), value objects (e.g., `UserStoryDraft`, `InterviewPhase`), and repositories (e.g., `ChatRepositoryInterface`). The domain layer is responsible for defining the rules and behavior of the interview process.
-2. **Application Layer**: This layer provides a service that orchestrates the interview process, including starting a new session, sending messages, and extracting the user story. The application layer uses the repository interface to interact with the data storage.
-3. **Infrastructure Layer**: This layer contains the implementation details for interacting with the LLM (Large Language Model). In this case, it's using LangChain + Ollama.
-
-## Components
-
-### Entities
-
-* `ChatMessage`: Represents a single message in the chat conversation.
-* `ChatSession`: Represents the entire conversation between the Product Owner and the user.
-
-### Value Objects
-
-* `UserStoryDraft`: Represents a draft user story extracted from the interview.
-* `InterviewPhase`: Represents the phases of the interview process (e.g., GREETING, CONTEXT_GATHERING).
-
-### Repositories
-
-* `ChatRepositoryInterface`: Defines the contract for interacting with the data storage.
-
-## Usage
-
-To use this domain, you can start a new session and send messages to initiate the conversation. The service will then extract the user story from the conversation and return it in a structured format.
-
-```python
-from src.application.user_story_chat import UserStoryChatService
-
-# Start a new session
-service = UserStoryChatService()
-session = service.start_session("my_workspace")
-
-# Send a message to initiate the conversation
-greeting = service.get_greeting()
-session.add_assistant_message(greeting)
-
-# Process user input and send responses
-user_input = "I want to create a new feature"
-assistant_response = service.process_user_input(user_input)
-session.add_assistant_message(assistant_response)
-
-# Extract the user story from the conversation
-draft = session.extract_story()
-print(draft.to_dict())
-```
-
-## API Reference
-
-The following methods are part of the `UserStoryChatService` class:
-
-* `start_session(workspace: str)`: Starts a new interview session.
-* `get_greeting()`: Returns the initial greeting message for the Product Owner.
-* `process_user_input(user_input: str)`: Processes user input and returns an assistant response.
-* `extract_story()`: Extracts the user story from the conversation.
-
-## Testing
-
-To run tests, use the following command:
-```bash
-pytest src/application/user_story_chat/
-```
-This will execute all tests in the `src/application/user_story_chat` directory.
-
-## Dependencies
-
-The domain depends on the following internal and external dependencies:
-
-* `langchain_ollama`: The LLM implementation used for interacting with the data storage.
-* `python-llamachain`: The LangChain library used to interact with the LLM.
-* `jsonschema`: Used to validate the user story draft.
-
-Note: This is a high-level overview of the domain. For more detailed information, please refer to the individual files and documentation.

package/src/domain/user_story_chat/__init__.py

@@ -1,34 +0,0 @@
-"""
-User Story Chat Domain - Bounded context for interactive user story creation.
-
-This domain handles the interview-based creation of user stories through
-a conversational interface powered by LLM (Product Owner persona).
-
-Components:
-- Entities: ChatSession, ChatMessage
-- Value Objects: MessageRole, InterviewPhase, UserStoryDraft, ChatConfig
-- Repositories: ChatRepositoryInterface, ChatSessionRepositoryInterface
-"""
-
-from .entities import ChatSession, ChatMessage
-from .value_objects import (
-    MessageRole,
-    InterviewPhase,
-    UserStoryDraft,
-    ChatConfig
-)
-from .repositories import ChatRepositoryInterface, ChatSessionRepositoryInterface
-
-__all__ = [
-    # Entities
-    'ChatSession',
-    'ChatMessage',
-    # Value Objects
-    'MessageRole',
-    'InterviewPhase',
-    'UserStoryDraft',
-    'ChatConfig',
-    # Repositories
-    'ChatRepositoryInterface',
-    'ChatSessionRepositoryInterface',
-]

package/src/domain/user_story_chat/entities.py

@@ -1,171 +0,0 @@
-"""
-Entities for User Story Chat bounded context.
-
-Entities have identity and lifecycle.
-"""
-
-from typing import Optional, List, Dict
-from datetime import datetime
-from ..shared import Entity, ValidationError
-from .value_objects import MessageRole, InterviewPhase, UserStoryDraft, ChatConfig
-
-
-class ChatMessage(Entity):
-    """Entity representing a single message in the chat."""
-
-    def __init__(
-        self,
-        role: MessageRole,
-        content: str,
-        phase: Optional[InterviewPhase] = None,
-        entity_id: Optional[str] = None
-    ):
-        super().__init__(entity_id)
-        self.role = role
-        self.content = content
-        self.phase = phase
-
-    def validate(self) -> bool:
-        """Validate message."""
-        if not self.content:
-            raise ValidationError("Message content cannot be empty")
-        if len(self.content) > 10000:
-            raise ValidationError("Message content too long (max 10000 chars)")
-        return True
-
-    def to_dict(self) -> Dict:
-        """Convert to dictionary representation."""
-        return {
-            'id': self.id,
-            'role': self.role.value,
-            'content': self.content,
-            'phase': self.phase.value if self.phase else None,
-            'created_at': self.created_at.isoformat()
-        }
-
-    def to_langchain_format(self) -> tuple:
-        """Convert to LangChain message format."""
-        return (self.role.value, self.content)
-
-
-class ChatSession(Entity):
-    """Entity representing a user story interview chat session."""
-
-    def __init__(
-        self,
-        workspace: str,
-        config: Optional[ChatConfig] = None,
-        entity_id: Optional[str] = None
-    ):
-        super().__init__(entity_id)
-        self.workspace = workspace
-        self.config = config or ChatConfig()
-        self.messages: List[ChatMessage] = []
-        self.current_phase = InterviewPhase.GREETING
-        self.extracted_story: Optional[UserStoryDraft] = None
-        self.is_active = True
-
-    def validate(self) -> bool:
-        """Validate session."""
-        if not self.workspace:
-            raise ValidationError("Workspace is required")
-        self.config.validate()
-        return True
-
-    def add_message(self, role: MessageRole, content: str) -> ChatMessage:
-        """Add a message to the session."""
-        message = ChatMessage(
-            role=role,
-            content=content,
-            phase=self.current_phase
-        )
-        message.validate()
-        self.messages.append(message)
-        self.update_timestamp()
-        return message
-
-    def add_system_message(self, content: str) -> ChatMessage:
-        """Add a system message."""
-        return self.add_message(MessageRole.SYSTEM, content)
-
-    def add_assistant_message(self, content: str) -> ChatMessage:
-        """Add an assistant (Product Owner) message."""
-        return self.add_message(MessageRole.ASSISTANT, content)
-
-    def add_user_message(self, content: str) -> ChatMessage:
-        """Add a user (Stakeholder) message."""
-        return self.add_message(MessageRole.USER, content)
-
-    def advance_phase(self) -> bool:
-        """Advance to the next interview phase."""
-        next_phase = self.current_phase.next_phase()
-        if next_phase:
-            self.current_phase = next_phase
-            self.update_timestamp()
-            return True
-        return False
-
-    def set_phase(self, phase: InterviewPhase) -> None:
-        """Set the current phase directly."""
-        self.current_phase = phase
-        self.update_timestamp()
-
-    def complete_interview(self, story_draft: UserStoryDraft) -> None:
-        """Complete the interview with the extracted story."""
-        story_draft.validate()
-        self.extracted_story = story_draft
-        self.current_phase = InterviewPhase.COMPLETED
-        self.is_active = False
-        self.update_timestamp()
-
-    def cancel_session(self) -> None:
-        """Cancel the chat session."""
-        self.is_active = False
-        self.update_timestamp()
-
-    def get_conversation_history(self) -> List[tuple]:
-        """Get conversation history in LangChain format."""
-        return [msg.to_langchain_format() for msg in self.messages]
-
-    def get_message_count(self) -> int:
-        """Get total message count."""
-        return len(self.messages)
-
-    def get_user_messages(self) -> List[ChatMessage]:
-        """Get only user messages."""
-        return [m for m in self.messages if m.role == MessageRole.USER]
-
-    def get_last_message(self) -> Optional[ChatMessage]:
-        """Get the last message in the session."""
-        return self.messages[-1] if self.messages else None
-
-    def is_complete(self) -> bool:
-        """Check if interview is complete."""
-        return self.current_phase == InterviewPhase.COMPLETED
-
-    def has_extracted_story(self) -> bool:
-        """Check if a story was extracted."""
-        return self.extracted_story is not None
-
-    def to_dict(self) -> Dict:
-        """Convert to dictionary representation."""
-        return {
-            'id': self.id,
-            'workspace': self.workspace,
-            'current_phase': self.current_phase.value,
-            'is_active': self.is_active,
-            'message_count': self.get_message_count(),
-            'has_story': self.has_extracted_story(),
-            'extracted_story': self.extracted_story.to_dict() if self.extracted_story else None,
-            'config': {
-                'model': self.config.model,
-                'temperature': self.config.temperature
-            },
-            'created_at': self.created_at.isoformat(),
-            'updated_at': self.updated_at.isoformat()
-        }
-
-    def get_interview_summary(self) -> str:
-        """Get a summary of the interview for context."""
-        user_inputs = [m.content for m in self.get_user_messages()]
-        return "\n".join(user_inputs[-5:])  # Last 5 user inputs for context

package/src/domain/user_story_chat/repositories.py

@@ -1,74 +0,0 @@
-"""
-Repository interfaces for User Story Chat bounded context.
-
-These are abstract interfaces that define the contract for persistence.
-Concrete implementations are in the infrastructure layer.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Optional, List
-from .entities import ChatSession, ChatMessage
-from .value_objects import UserStoryDraft
-
-
-class ChatRepositoryInterface(ABC):
-    """Abstract interface for chat operations with LLM."""
-
-    @abstractmethod
-    def initialize(self, session: ChatSession) -> None:
-        """Initialize the chat repository with session config."""
-        pass
-
-    @abstractmethod
-    def send_message(self, session: ChatSession, user_input: str) -> str:
-        """Send a message and get the assistant response.
-
-        Args:
-            session: The chat session with history
-            user_input: The user's input message
-
-        Returns:
-            The assistant's response
-        """
-        pass
-
-    @abstractmethod
-    def extract_story(self, session: ChatSession) -> UserStoryDraft:
-        """Extract a structured user story from the conversation.
-
-        Args:
-            session: The completed chat session
-
-        Returns:
-            Extracted user story draft
-        """
-        pass
-
-    @abstractmethod
-    def get_system_prompt(self) -> str:
-        """Get the system prompt for the Product Owner persona."""
-        pass
-
-
-class ChatSessionRepositoryInterface(ABC):
-    """Abstract interface for persisting chat sessions."""
-
-    @abstractmethod
-    def save(self, session: ChatSession) -> None:
-        """Save a chat session."""
-        pass
-
-    @abstractmethod
-    def find_by_id(self, session_id: str) -> Optional[ChatSession]:
-        """Find a session by ID."""
-        pass
-
-    @abstractmethod
-    def find_by_workspace(self, workspace: str) -> List[ChatSession]:
-        """Find all sessions for a workspace."""
-        pass
-
-    @abstractmethod
-    def delete(self, session_id: str) -> bool:
-        """Delete a session."""
-        pass

package/src/domain/user_story_chat/value_objects.py

@@ -1,140 +0,0 @@
-"""
-Value Objects for User Story Chat bounded context.
-
-Value objects are immutable and defined by their attributes.
-"""
-
-from enum import Enum
-from dataclasses import dataclass
-from typing import Optional, List
-from ..shared import ValidationError
-
-
-class MessageRole(Enum):
-    """Role of a message in the chat."""
-    SYSTEM = "system"
-    ASSISTANT = "assistant"
-    USER = "user"
-
-    @classmethod
-    def from_string(cls, value: str) -> 'MessageRole':
-        """Create role from string."""
-        normalized = value.lower().strip()
-        for role in cls:
-            if role.value == normalized:
-                return role
-        raise ValidationError(f"Invalid message role: {value}")
-
-
-class InterviewPhase(Enum):
-    """Phases of the user story interview process."""
-    GREETING = "greeting"
-    CONTEXT_GATHERING = "context_gathering"
-    ACTOR_IDENTIFICATION = "actor_identification"
-    NEED_EXPLORATION = "need_exploration"
-    VALUE_CLARIFICATION = "value_clarification"
-    ACCEPTANCE_CRITERIA = "acceptance_criteria"
-    CONSTRAINTS_DISCUSSION = "constraints_discussion"
-    SUMMARY_CONFIRMATION = "summary_confirmation"
-    COMPLETED = "completed"
-
-    def get_order(self) -> int:
-        """Get phase order for progression tracking."""
-        order = {
-            InterviewPhase.GREETING: 0,
-            InterviewPhase.CONTEXT_GATHERING: 1,
-            InterviewPhase.ACTOR_IDENTIFICATION: 2,
-            InterviewPhase.NEED_EXPLORATION: 3,
-            InterviewPhase.VALUE_CLARIFICATION: 4,
-            InterviewPhase.ACCEPTANCE_CRITERIA: 5,
-            InterviewPhase.CONSTRAINTS_DISCUSSION: 6,
-            InterviewPhase.SUMMARY_CONFIRMATION: 7,
-            InterviewPhase.COMPLETED: 8,
-        }
-        return order[self]
-
-    def next_phase(self) -> Optional['InterviewPhase']:
-        """Get the next phase in the interview process."""
-        phases = list(InterviewPhase)
-        current_idx = phases.index(self)
-        if current_idx < len(phases) - 1:
-            return phases[current_idx + 1]
-        return None
-
-    def is_terminal(self) -> bool:
-        """Check if this is the final phase."""
-        return self == InterviewPhase.COMPLETED
-
-    @classmethod
-    def from_string(cls, value: str) -> 'InterviewPhase':
-        """Create phase from string."""
-        normalized = value.lower().strip()
-        for phase in cls:
-            if phase.value == normalized:
-                return phase
-        raise ValidationError(f"Invalid interview phase: {value}")
-
-
-@dataclass(frozen=True)
-class UserStoryDraft:
-    """Value object representing a draft user story extracted from interview."""
-    title: str
-    as_a: str
-    i_want: str
-    so_that: str
-    acceptance_criteria: List[str]
-    technical_constraints: List[str]
-    priority_suggestion: str
-    notes: Optional[str] = None
-
-    def validate(self) -> bool:
-        """Validate the draft user story."""
-        if not self.title or len(self.title) > 150:
-            raise ValidationError("Title must be 1-150 characters")
-        if not self.as_a or len(self.as_a) > 50:
-            raise ValidationError("As_a must be 1-50 characters")
-        if not self.i_want or len(self.i_want) > 200:
-            raise ValidationError("I_want must be 1-200 characters")
-        if not self.so_that or len(self.so_that) > 200:
-            raise ValidationError("So_that must be 1-200 characters")
-        if len(self.acceptance_criteria) < 1:
-            raise ValidationError("At least one acceptance criterion is required")
-        return True
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary representation."""
-        return {
-            'title': self.title,
-            'as_a': self.as_a,
-            'i_want': self.i_want,
-            'so_that': self.so_that,
-            'acceptance_criteria': self.acceptance_criteria,
-            'technical_constraints': self.technical_constraints,
-            'priority_suggestion': self.priority_suggestion,
-            'notes': self.notes
-        }
-
-    def to_user_story_format(self) -> str:
-        """Format as traditional user story string."""
-        story = f"As a {self.as_a}, I want {self.i_want} so that {self.so_that}."
-        return story
-
-
-@dataclass(frozen=True)
-class ChatConfig:
-    """Configuration for chat session."""
-    model: str = "llama3.1:8b"
-    temperature: float = 0.7
-    max_tokens: int = 1000
-    ollama_host: str = "http://localhost:11434"
-    timeout: int = 120
-
-    def validate(self) -> bool:
-        """Validate configuration."""
-        if not self.model:
-            raise ValidationError("Model name is required")
-        if not 0.0 <= self.temperature <= 2.0:
-            raise ValidationError("Temperature must be between 0.0 and 2.0")
-        if self.max_tokens < 100:
-            raise ValidationError("Max tokens must be at least 100")
-        return True

package/src/domain/workspace/README.md

@@ -1,114 +0,0 @@
-🤖 Using: llama3.2:3b (temp=0.3)
-✅ Completed in 23.1s
-# Domain: Workspace
-
-## Overview
-
-The Workspace domain represents a bounded context for managing workspaces. It provides a set of value objects, entities, and use cases to create, list, and manage workspaces.
-
-## Architecture
-
-The architecture consists of three layers:
-
-1. **Domain Layer**: This layer contains the core business logic for workspace management.
-2. **Application Layer**: This layer provides the application service and use cases for workspace management.
-3. **Infrastructure Layer**: This layer uses a SQLite database to store and retrieve workspace data.
-
-## Components
-
-### Entities
-
-*   `Workspace`: Represents a single workspace entity, containing configuration, state, and metrics.
-*   `WorkspaceConfig`: Represents the configuration of a workspace, including name, context type, language, framework, description, tags, phase, status, created date, and updated date.
-
-### Value Objects
-
-*   `WorkspacePath`: Represents a file system path for a workspace, ensuring consistency across the workspace.
-*   `WorkspaceMetrics`: Represents usage metrics for a workspace, tracking total artifacts, disk usage, API tokens used, API cost, local model tokens, and last accessed date.
-
-### Use Cases
-
-*   `CreateWorkspaceUseCase`: Creates a new workspace with configuration.
-*   `ListWorkspacesUseCase`: Retrieves all workspaces in a directory.
-
-## Usage
-
-To use the Workspace domain, you can create a new workspace using the `CreateWorkspaceUseCase`:
-
-```python
-from src.application.workspace import CreateWorkspaceService
-from src.domain.workspace import CreateWorkspaceRequest
-
-# Create a new workspace service
-service = CreateWorkspaceService()
-
-# Define the workspace configuration
-config = CreateWorkspaceRequest(
-    name="My Workspace",
-    context_type="my_context",
-    language="Python",
-    framework="Flask"
-)
-
-# Execute the create workspace use case
-response = service.execute(config)
-print(response.to_dict())
-```
-
-To list all workspaces in a directory, you can use the `ListWorkspacesUseCase`:
-
-```python
-from src.application.workspace import ListWorkspacesService
-
-# Create a new workspace service
-service = ListWorkspacesService()
-
-# Execute the list workspaces use case
-response = service.execute(ListWorkspacesRequest())
-print(response.to_dict())
-```
-
-## API Reference
-
-### WorkspaceRepository
-
-*   `find_by_name(name: str) -> Optional[Workspace]`: Finds a workspace by name.
-*   `find_by_root_path(root_path: Path) -> Optional[Workspace]`: Finds a workspace by its root path.
-
-### WorkspaceService
-
-*   `create_workspace(config: WorkspaceConfig) -> Workspace`: Creates a new workspace with configuration.
-*   `get_workspace(name: str) -> Workspace`: Retrieves an existing workspace by name.
-
-### CreateWorkspaceUseCase
-
-*   `execute(request: CreateWorkspaceRequest) -> CreateWorkspaceResponse`: Executes the create workspace use case.
-
-### ListWorkspacesUseCase
-
-*   `execute(request: ListWorkspacesRequest) -> ListWorkspacesResponse`: Executes the list workspaces use case.
-
-## Testing
-
-To run tests, navigate to the project directory and execute:
-
-```bash
-pytest
-```
-
-This will run all tests in the project using the pytest framework.
-
-## Dependencies
-
-The Workspace domain depends on the following internal dependencies:
-
-*   `domain.workspace_repository`
-*   `application.workspace_service`
-*   `infrastructure.workspace_sqlite_repository`
-
-It also depends on the following external dependencies:
-
-*   `sqlite3` (for SQLite database interactions)
-*   `pathlib` (for file system path management)
-
-Note: This README is a generated version, and you may need to adjust it according to your specific project requirements.

package/src/domain/workspace/__init__.py

@@ -1,74 +0,0 @@
-"""
-Workspace bounded context.
-
-Domain model for workspace management, including workspace entities,
-dependencies, events, and related value objects.
-"""
-
-from .workspace import Workspace, WorkspaceConfig, WorkspaceMetrics, WorkspaceStructure
-from .workspace_repository import WorkspaceRepository, WorkspaceDependencyRepository
-from .value_objects import (
-    WorkspacePath,
-    WorkspaceConfig as WorkspaceConfigVO,
-    WorkspaceState,
-    WorkspaceMetrics as WorkspaceMetricsVO,
-    WorkspacePhase,
-    WorkspaceStatus
-)
-from .entities import WorkspaceDependency, DependencyType
-from .events import (
-    WorkspaceEvent,
-    ErrorDetected,
-    FixRequired,
-    ChangeApplied,
-    BuildStarted,
-    BuildCompleted,
-    ContextSynchronized,
-    DependencyValidated
-)
-from .event_handlers import (
-    WorkspaceEventHandler,
-    CompositeEventHandler,
-    AsyncEventHandler
-)
-
-__all__ = [
-    # Core entities
-    "Workspace",
-    "WorkspaceDependency",
-
-    # Configuration and structure
-    "WorkspaceConfig",
-    "WorkspaceMetrics",
-    "WorkspaceStructure",
-
-    # Repositories
-    "WorkspaceRepository",
-    "WorkspaceDependencyRepository",
-
-    # Value objects
-    "WorkspacePath",
-    "WorkspaceConfigVO",
-    "WorkspaceState",
-    "WorkspaceMetricsVO",
-    "WorkspacePhase",
-    "WorkspaceStatus",
-
-    # Enums
-    "DependencyType",
-
-    # Events
-    "WorkspaceEvent",
-    "ErrorDetected",
-    "FixRequired",
-    "ChangeApplied",
-    "BuildStarted",
-    "BuildCompleted",
-    "ContextSynchronized",
-    "DependencyValidated",
-
-    # Event Handlers
-    "WorkspaceEventHandler",
-    "CompositeEventHandler",
-    "AsyncEventHandler",
-]