deepwork 0.1.0__py3-none-any.whl

deepwork/core/generator.py

@@ -0,0 +1,290 @@
+"""Slash-command file generator using Jinja2 templates."""
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, TemplateNotFound
+
+from deepwork.core.adapters import AgentAdapter, CommandLifecycleHook
+from deepwork.core.parser import JobDefinition, Step
+from deepwork.schemas.job_schema import LIFECYCLE_HOOK_EVENTS
+from deepwork.utils.fs import safe_read, safe_write
+
+
+class GeneratorError(Exception):
+    """Exception raised for command generation errors."""
+
+    pass
+
+
+class CommandGenerator:
+    """Generates slash-command files from job definitions."""
+
+    def __init__(self, templates_dir: Path | str | None = None):
+        """
+        Initialize generator.
+
+        Args:
+            templates_dir: Path to templates directory
+                          (defaults to package templates directory)
+        """
+        if templates_dir is None:
+            # Use package templates directory
+            templates_dir = Path(__file__).parent.parent / "templates"
+
+        self.templates_dir = Path(templates_dir)
+
+        if not self.templates_dir.exists():
+            raise GeneratorError(f"Templates directory not found: {self.templates_dir}")
+
+    def _get_jinja_env(self, adapter: AgentAdapter) -> Environment:
+        """
+        Get Jinja2 environment for an adapter.
+
+        Args:
+            adapter: Agent adapter
+
+        Returns:
+            Jinja2 Environment
+        """
+        platform_templates_dir = adapter.get_template_dir(self.templates_dir)
+        if not platform_templates_dir.exists():
+            raise GeneratorError(
+                f"Templates for platform '{adapter.name}' not found at {platform_templates_dir}"
+            )
+
+        return Environment(
+            loader=FileSystemLoader(platform_templates_dir),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def _is_standalone_step(self, job: JobDefinition, step: Step) -> bool:
+        """
+        Check if a step is standalone (disconnected from the main workflow).
+
+        A standalone step has no dependencies AND no other steps depend on it.
+
+        Args:
+            job: Job definition
+            step: Step to check
+
+        Returns:
+            True if step is standalone
+        """
+        # Step has dependencies - not standalone
+        if step.dependencies:
+            return False
+
+        # Check if any other step depends on this step
+        for other_step in job.steps:
+            if step.id in other_step.dependencies:
+                return False
+
+        return True
+
+    def _build_hook_context(self, job: JobDefinition, hook_action: Any) -> dict[str, Any]:
+        """
+        Build context for a single hook action.
+
+        Args:
+            job: Job definition
+            hook_action: HookAction instance
+
+        Returns:
+            Hook context dictionary
+        """
+        hook_ctx: dict[str, Any] = {}
+        if hook_action.is_prompt():
+            hook_ctx["type"] = "prompt"
+            hook_ctx["content"] = hook_action.prompt
+        elif hook_action.is_prompt_file():
+            hook_ctx["type"] = "prompt_file"
+            hook_ctx["path"] = hook_action.prompt_file
+            # Read the prompt file content
+            prompt_file_path = job.job_dir / hook_action.prompt_file
+            prompt_content = safe_read(prompt_file_path)
+            if prompt_content is None:
+                raise GeneratorError(f"Hook prompt file not found: {prompt_file_path}")
+            hook_ctx["content"] = prompt_content
+        elif hook_action.is_script():
+            hook_ctx["type"] = "script"
+            hook_ctx["path"] = hook_action.script
+        return hook_ctx
+
+    def _build_step_context(
+        self, job: JobDefinition, step: Step, step_index: int, adapter: AgentAdapter
+    ) -> dict[str, Any]:
+        """
+        Build template context for a step.
+
+        Args:
+            job: Job definition
+            step: Step to generate context for
+            step_index: Index of step in job (0-based)
+            adapter: Agent adapter for platform-specific hook name mapping
+
+        Returns:
+            Template context dictionary
+        """
+        # Read step instructions
+        instructions_file = job.job_dir / step.instructions_file
+        instructions_content = safe_read(instructions_file)
+        if instructions_content is None:
+            raise GeneratorError(f"Step instructions file not found: {instructions_file}")
+
+        # Separate user inputs and file inputs
+        user_inputs = [
+            {"name": inp.name, "description": inp.description}
+            for inp in step.inputs
+            if inp.is_user_input()
+        ]
+        file_inputs = [
+            {"file": inp.file, "from_step": inp.from_step}
+            for inp in step.inputs
+            if inp.is_file_input()
+        ]
+
+        # Check if this is a standalone step
+        is_standalone = self._is_standalone_step(job, step)
+
+        # Determine next and previous steps (only for non-standalone steps)
+        next_step = None
+        prev_step = None
+        if not is_standalone:
+            if step_index < len(job.steps) - 1:
+                next_step = job.steps[step_index + 1].id
+            if step_index > 0:
+                prev_step = job.steps[step_index - 1].id
+
+        # Build hooks context for all lifecycle events
+        # Structure: {platform_event_name: [hook_contexts]}
+        hooks: dict[str, list[dict[str, Any]]] = {}
+        for event in LIFECYCLE_HOOK_EVENTS:
+            if event in step.hooks:
+                # Get platform-specific event name from adapter
+                hook_enum = CommandLifecycleHook(event)
+                platform_event_name = adapter.get_platform_hook_name(hook_enum)
+                if platform_event_name:
+                    hook_contexts = [
+                        self._build_hook_context(job, hook_action)
+                        for hook_action in step.hooks[event]
+                    ]
+                    if hook_contexts:
+                        hooks[platform_event_name] = hook_contexts
+
+        # Backward compatibility: stop_hooks is after_agent hooks
+        stop_hooks = hooks.get(
+            adapter.get_platform_hook_name(CommandLifecycleHook.AFTER_AGENT) or "Stop", []
+        )
+
+        return {
+            "job_name": job.name,
+            "job_version": job.version,
+            "job_summary": job.summary,
+            "job_description": job.description,
+            "step_id": step.id,
+            "step_name": step.name,
+            "step_description": step.description,
+            "step_number": step_index + 1,  # 1-based for display
+            "total_steps": len(job.steps),
+            "instructions_file": step.instructions_file,
+            "instructions_content": instructions_content,
+            "user_inputs": user_inputs,
+            "file_inputs": file_inputs,
+            "outputs": step.outputs,
+            "dependencies": step.dependencies,
+            "next_step": next_step,
+            "prev_step": prev_step,
+            "is_standalone": is_standalone,
+            "hooks": hooks,  # New: all hooks by platform event name
+            "stop_hooks": stop_hooks,  # Backward compat: after_agent hooks only
+        }
+
+    def generate_step_command(
+        self,
+        job: JobDefinition,
+        step: Step,
+        adapter: AgentAdapter,
+        output_dir: Path | str,
+    ) -> Path:
+        """
+        Generate slash-command file for a single step.
+
+        Args:
+            job: Job definition
+            step: Step to generate command for
+            adapter: Agent adapter for the target platform
+            output_dir: Directory to write command file to
+
+        Returns:
+            Path to generated command file
+
+        Raises:
+            GeneratorError: If generation fails
+        """
+        output_dir = Path(output_dir)
+
+        # Create commands subdirectory if needed
+        commands_dir = output_dir / adapter.commands_dir
+        commands_dir.mkdir(parents=True, exist_ok=True)
+
+        # Find step index
+        try:
+            step_index = next(i for i, s in enumerate(job.steps) if s.id == step.id)
+        except StopIteration as e:
+            raise GeneratorError(f"Step '{step.id}' not found in job '{job.name}'") from e
+
+        # Build context
+        context = self._build_step_context(job, step, step_index, adapter)
+
+        # Load and render template
+        env = self._get_jinja_env(adapter)
+        try:
+            template = env.get_template(adapter.command_template)
+        except TemplateNotFound as e:
+            raise GeneratorError(f"Template not found: {e}") from e
+
+        try:
+            rendered = template.render(**context)
+        except Exception as e:
+            raise GeneratorError(f"Template rendering failed: {e}") from e
+
+        # Write command file
+        command_filename = adapter.get_command_filename(job.name, step.id)
+        command_path = commands_dir / command_filename
+
+        try:
+            safe_write(command_path, rendered)
+        except Exception as e:
+            raise GeneratorError(f"Failed to write command file: {e}") from e
+
+        return command_path
+
+    def generate_all_commands(
+        self,
+        job: JobDefinition,
+        adapter: AgentAdapter,
+        output_dir: Path | str,
+    ) -> list[Path]:
+        """
+        Generate slash-command files for all steps in a job.
+
+        Args:
+            job: Job definition
+            adapter: Agent adapter for the target platform
+            output_dir: Directory to write command files to
+
+        Returns:
+            List of paths to generated command files
+
+        Raises:
+            GeneratorError: If generation fails
+        """
+        command_paths = []
+
+        for step in job.steps:
+            command_path = self.generate_step_command(job, step, adapter, output_dir)
+            command_paths.append(command_path)
+
+        return command_paths

deepwork/core/hooks_syncer.py

@@ -0,0 +1,206 @@
+"""Hooks syncer for DeepWork - collects and syncs hooks from jobs to platform settings."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from deepwork.core.adapters import AgentAdapter
+
+
+class HooksSyncError(Exception):
+    """Exception raised for hooks sync errors."""
+
+    pass
+
+
+@dataclass
+class HookEntry:
+    """Represents a single hook entry for a lifecycle event."""
+
+    script: str  # Script filename
+    job_name: str  # Job that provides this hook
+    job_dir: Path  # Full path to job directory
+
+    def get_script_path(self, project_path: Path) -> str:
+        """
+        Get the script path relative to project root.
+
+        Args:
+            project_path: Path to project root
+
+        Returns:
+            Relative path to script from project root
+        """
+        # Script path is: .deepwork/jobs/{job_name}/hooks/{script}
+        script_path = self.job_dir / "hooks" / self.script
+        try:
+            return str(script_path.relative_to(project_path))
+        except ValueError:
+            # If not relative, return the full path
+            return str(script_path)
+
+
+@dataclass
+class JobHooks:
+    """Hooks configuration for a job."""
+
+    job_name: str
+    job_dir: Path
+    hooks: dict[str, list[str]] = field(default_factory=dict)  # event -> [scripts]
+
+    @classmethod
+    def from_job_dir(cls, job_dir: Path) -> "JobHooks | None":
+        """
+        Load hooks configuration from a job directory.
+
+        Args:
+            job_dir: Path to job directory containing hooks/global_hooks.yml
+
+        Returns:
+            JobHooks instance or None if no hooks defined
+        """
+        hooks_file = job_dir / "hooks" / "global_hooks.yml"
+        if not hooks_file.exists():
+            return None
+
+        try:
+            with open(hooks_file, encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+        except (yaml.YAMLError, OSError):
+            return None
+
+        if not data or not isinstance(data, dict):
+            return None
+
+        # Parse hooks - each key is an event, value is list of scripts
+        hooks: dict[str, list[str]] = {}
+        for event, scripts in data.items():
+            if isinstance(scripts, list):
+                hooks[event] = [str(s) for s in scripts]
+            elif isinstance(scripts, str):
+                hooks[event] = [scripts]
+
+        if not hooks:
+            return None
+
+        return cls(
+            job_name=job_dir.name,
+            job_dir=job_dir,
+            hooks=hooks,
+        )
+
+
+def collect_job_hooks(jobs_dir: Path) -> list[JobHooks]:
+    """
+    Collect hooks from all jobs in the jobs directory.
+
+    Args:
+        jobs_dir: Path to .deepwork/jobs directory
+
+    Returns:
+        List of JobHooks for all jobs with hooks defined
+    """
+    if not jobs_dir.exists():
+        return []
+
+    job_hooks_list = []
+    for job_dir in jobs_dir.iterdir():
+        if not job_dir.is_dir():
+            continue
+
+        job_hooks = JobHooks.from_job_dir(job_dir)
+        if job_hooks:
+            job_hooks_list.append(job_hooks)
+
+    return job_hooks_list
+
+
+def merge_hooks_for_platform(
+    job_hooks_list: list[JobHooks],
+    project_path: Path,
+) -> dict[str, list[dict[str, Any]]]:
+    """
+    Merge hooks from multiple jobs into a single configuration.
+
+    Args:
+        job_hooks_list: List of JobHooks from different jobs
+        project_path: Path to project root for relative path calculation
+
+    Returns:
+        Dict mapping lifecycle events to hook configurations
+    """
+    merged: dict[str, list[dict[str, Any]]] = {}
+
+    for job_hooks in job_hooks_list:
+        for event, scripts in job_hooks.hooks.items():
+            if event not in merged:
+                merged[event] = []
+
+            for script in scripts:
+                entry = HookEntry(
+                    script=script,
+                    job_name=job_hooks.job_name,
+                    job_dir=job_hooks.job_dir,
+                )
+                script_path = entry.get_script_path(project_path)
+
+                # Create hook configuration for Claude Code format
+                hook_config = {
+                    "matcher": "",  # Match all
+                    "hooks": [
+                        {
+                            "type": "command",
+                            "command": script_path,
+                        }
+                    ],
+                }
+
+                # Check if this hook is already present (avoid duplicates)
+                if not _hook_already_present(merged[event], script_path):
+                    merged[event].append(hook_config)
+
+    return merged
+
+
+def _hook_already_present(hooks: list[dict[str, Any]], script_path: str) -> bool:
+    """Check if a hook with the given script path is already in the list."""
+    for hook in hooks:
+        hook_list = hook.get("hooks", [])
+        for h in hook_list:
+            if h.get("command") == script_path:
+                return True
+    return False
+
+
+def sync_hooks_to_platform(
+    project_path: Path,
+    adapter: AgentAdapter,
+    job_hooks_list: list[JobHooks],
+) -> int:
+    """
+    Sync hooks from jobs to a specific platform's settings.
+
+    Args:
+        project_path: Path to project root
+        adapter: Agent adapter for the target platform
+        job_hooks_list: List of JobHooks from jobs
+
+    Returns:
+        Number of hooks synced
+
+    Raises:
+        HooksSyncError: If sync fails
+    """
+    # Merge hooks from all jobs
+    merged_hooks = merge_hooks_for_platform(job_hooks_list, project_path)
+
+    if not merged_hooks:
+        return 0
+
+    # Delegate to adapter's sync_hooks method
+    try:
+        return adapter.sync_hooks(project_path, merged_hooks)
+    except Exception as e:
+        raise HooksSyncError(f"Failed to sync hooks: {e}") from e