deepwork 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

deepwork/hooks/evaluate_policies.py

@@ -1,376 +0,0 @@
-"""
-Policy evaluation module for DeepWork hooks.
-
-This module is called by the policy_stop_hook.sh script to evaluate which policies
-should fire based on changed files and conversation context.
-
-Usage:
-    python -m deepwork.hooks.evaluate_policies \
-        --policy-file .deepwork.policy.yml
-
-The conversation context is read from stdin and checked for <promise> tags
-that indicate policies have already been addressed.
-
-Changed files are computed based on each policy's compare_to setting:
-- base: Compare to merge-base with default branch (default)
-- default_tip: Two-dot diff against default branch tip
-- prompt: Compare to state captured at prompt submission
-
-Output is JSON suitable for Claude Code Stop hooks:
-    {"decision": "block", "reason": "..."}  # Block stop, policies need attention
-    {}  # No policies fired, allow stop
-"""
-
-import argparse
-import json
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-from deepwork.core.policy_parser import (
-    Policy,
-    PolicyParseError,
-    evaluate_policy,
-    parse_policy_file,
-)
-
-
-def get_default_branch() -> str:
-    """
-    Get the default branch name (main or master).
-
-    Returns:
-        Default branch name, or "main" if cannot be determined.
-    """
-    # Try to get the default branch from remote HEAD
-    try:
-        result = subprocess.run(
-            ["git", "symbolic-ref", "refs/remotes/origin/HEAD"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        # Output is like "refs/remotes/origin/main"
-        return result.stdout.strip().split("/")[-1]
-    except subprocess.CalledProcessError:
-        pass
-
-    # Try common default branch names
-    for branch in ["main", "master"]:
-        try:
-            subprocess.run(
-                ["git", "rev-parse", "--verify", f"origin/{branch}"],
-                capture_output=True,
-                check=True,
-            )
-            return branch
-        except subprocess.CalledProcessError:
-            continue
-
-    # Fall back to main
-    return "main"
-
-
-def get_changed_files_base() -> list[str]:
-    """
-    Get files changed relative to the base of the current branch.
-
-    This finds the merge-base between the current branch and the default branch,
-    then returns all files changed since that point.
-
-    Returns:
-        List of changed file paths.
-    """
-    default_branch = get_default_branch()
-
-    try:
-        # Get the merge-base (where current branch diverged from default)
-        result = subprocess.run(
-            ["git", "merge-base", "HEAD", f"origin/{default_branch}"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        merge_base = result.stdout.strip()
-
-        # Stage all changes so they appear in diff
-        subprocess.run(["git", "add", "-A"], capture_output=True, check=False)
-
-        # Get files changed since merge-base (including staged)
-        result = subprocess.run(
-            ["git", "diff", "--name-only", merge_base, "HEAD"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        committed_files = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
-
-        # Also get staged changes not yet committed
-        result = subprocess.run(
-            ["git", "diff", "--name-only", "--cached"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        staged_files = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
-
-        # Get untracked files
-        result = subprocess.run(
-            ["git", "ls-files", "--others", "--exclude-standard"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        untracked_files = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
-
-        all_files = committed_files | staged_files | untracked_files
-        return sorted([f for f in all_files if f])
-
-    except subprocess.CalledProcessError:
-        return []
-
-
-def get_changed_files_default_tip() -> list[str]:
-    """
-    Get files changed compared to the tip of the default branch.
-
-    This does a two-dot diff: what's different between HEAD and origin/default.
-
-    Returns:
-        List of changed file paths.
-    """
-    default_branch = get_default_branch()
-
-    try:
-        # Stage all changes so they appear in diff
-        subprocess.run(["git", "add", "-A"], capture_output=True, check=False)
-
-        # Two-dot diff against default branch tip
-        result = subprocess.run(
-            ["git", "diff", "--name-only", f"origin/{default_branch}..HEAD"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        committed_files = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
-
-        # Also get staged changes not yet committed
-        result = subprocess.run(
-            ["git", "diff", "--name-only", "--cached"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        staged_files = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
-
-        # Get untracked files
-        result = subprocess.run(
-            ["git", "ls-files", "--others", "--exclude-standard"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        untracked_files = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
-
-        all_files = committed_files | staged_files | untracked_files
-        return sorted([f for f in all_files if f])
-
-    except subprocess.CalledProcessError:
-        return []
-
-
-def get_changed_files_prompt() -> list[str]:
-    """
-    Get files changed since the prompt was submitted.
-
-    This compares against the baseline captured by capture_prompt_work_tree.sh.
-
-    Returns:
-        List of changed file paths.
-    """
-    baseline_path = Path(".deepwork/.last_work_tree")
-
-    try:
-        # Stage all changes so we can see them with --cached
-        subprocess.run(["git", "add", "-A"], capture_output=True, check=False)
-
-        # Get all staged files (includes what was just staged)
-        result = subprocess.run(
-            ["git", "diff", "--name-only", "--cached"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        current_files = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
-        current_files = {f for f in current_files if f}
-
-        if baseline_path.exists():
-            # Read baseline and find new files
-            baseline_files = set(baseline_path.read_text().strip().split("\n"))
-            baseline_files = {f for f in baseline_files if f}
-            # Return files that are in current but not in baseline
-            new_files = current_files - baseline_files
-            return sorted(new_files)
-        else:
-            # No baseline, return all current changes
-            return sorted(current_files)
-
-    except (subprocess.CalledProcessError, OSError):
-        return []
-
-
-def get_changed_files_for_mode(mode: str) -> list[str]:
-    """
-    Get changed files for a specific compare_to mode.
-
-    Args:
-        mode: One of 'base', 'default_tip', or 'prompt'
-
-    Returns:
-        List of changed file paths.
-    """
-    if mode == "base":
-        return get_changed_files_base()
-    elif mode == "default_tip":
-        return get_changed_files_default_tip()
-    elif mode == "prompt":
-        return get_changed_files_prompt()
-    else:
-        # Unknown mode, fall back to base
-        return get_changed_files_base()
-
-
-def extract_promise_tags(text: str) -> set[str]:
-    """
-    Extract policy names from <promise> tags in text.
-
-    Supported format:
-    - <promise>✓ Policy Name</promise>
-
-    Args:
-        text: Text to search for promise tags
-
-    Returns:
-        Set of policy names that have been promised/addressed
-    """
-    # Match <promise>✓ Policy Name</promise> and extract the policy name
-    pattern = r"<promise>✓\s*([^<]+)</promise>"
-    matches = re.findall(pattern, text, re.IGNORECASE | re.DOTALL)
-    return {m.strip() for m in matches}
-
-
-def format_policy_message(policies: list) -> str:
-    """
-    Format triggered policies into a message for the agent.
-
-    Args:
-        policies: List of Policy objects that fired
-
-    Returns:
-        Formatted message with all policy instructions
-    """
-    lines = ["## DeepWork Policies Triggered", ""]
-    lines.append(
-        "Comply with the following policies. "
-        "To mark a policy as addressed, include `<promise>✓ Policy Name</promise>` "
-        "in your response (replace Policy Name with the actual policy name)."
-    )
-    lines.append("")
-
-    for policy in policies:
-        lines.append(f"### Policy: {policy.name}")
-        lines.append("")
-        lines.append(policy.instructions.strip())
-        lines.append("")
-
-    return "\n".join(lines)
-
-
-def main() -> None:
-    """Main entry point for policy evaluation CLI."""
-    parser = argparse.ArgumentParser(
-        description="Evaluate DeepWork policies based on changed files"
-    )
-    parser.add_argument(
-        "--policy-file",
-        type=str,
-        required=True,
-        help="Path to .deepwork.policy.yml file",
-    )
-
-    args = parser.parse_args()
-
-    # Check if policy file exists
-    policy_path = Path(args.policy_file)
-    if not policy_path.exists():
-        # No policy file, nothing to evaluate
-        print("{}")
-        return
-
-    # Read conversation context from stdin (if available)
-    conversation_context = ""
-    if not sys.stdin.isatty():
-        try:
-            conversation_context = sys.stdin.read()
-        except Exception:
-            pass
-
-    # Extract promise tags from conversation
-    promised_policies = extract_promise_tags(conversation_context)
-
-    # Parse policies
-    try:
-        policies = parse_policy_file(policy_path)
-    except PolicyParseError as e:
-        # Log error to stderr, return empty result
-        print(f"Error parsing policy file: {e}", file=sys.stderr)
-        print("{}")
-        return
-
-    if not policies:
-        # No policies defined
-        print("{}")
-        return
-
-    # Group policies by compare_to mode to minimize git calls
-    policies_by_mode: dict[str, list[Policy]] = {}
-    for policy in policies:
-        mode = policy.compare_to
-        if mode not in policies_by_mode:
-            policies_by_mode[mode] = []
-        policies_by_mode[mode].append(policy)
-
-    # Get changed files for each mode and evaluate policies
-    fired_policies: list[Policy] = []
-    for mode, mode_policies in policies_by_mode.items():
-        changed_files = get_changed_files_for_mode(mode)
-        if not changed_files:
-            continue
-
-        for policy in mode_policies:
-            # Skip if already promised
-            if policy.name in promised_policies:
-                continue
-            # Evaluate this policy
-            if evaluate_policy(policy, changed_files):
-                fired_policies.append(policy)
-
-    if not fired_policies:
-        # No policies fired
-        print("{}")
-        return
-
-    # Format output for Claude Code Stop hooks
-    # Use "decision": "block" to prevent Claude from stopping
-    message = format_policy_message(fired_policies)
-    result = {
-        "decision": "block",
-        "reason": message,
-    }
-
-    print(json.dumps(result))
-
-
-if __name__ == "__main__":
-    main()

deepwork/schemas/policy_schema.py

@@ -1,78 +0,0 @@
-"""JSON Schema definition for policy definitions."""
-
-from typing import Any
-
-# JSON Schema for .deepwork.policy.yml files
-# Policies are defined as an array of policy objects
-POLICY_SCHEMA: dict[str, Any] = {
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "type": "array",
-    "description": "List of policies that trigger based on file changes",
-    "items": {
-        "type": "object",
-        "required": ["name", "trigger"],
-        "properties": {
-            "name": {
-                "type": "string",
-                "minLength": 1,
-                "description": "Friendly name for the policy",
-            },
-            "trigger": {
-                "oneOf": [
-                    {
-                        "type": "string",
-                        "minLength": 1,
-                        "description": "Glob pattern for files that trigger this policy",
-                    },
-                    {
-                        "type": "array",
-                        "items": {"type": "string", "minLength": 1},
-                        "minItems": 1,
-                        "description": "List of glob patterns for files that trigger this policy",
-                    },
-                ],
-                "description": "Glob pattern(s) for files that, if changed, should trigger this policy",
-            },
-            "safety": {
-                "oneOf": [
-                    {
-                        "type": "string",
-                        "minLength": 1,
-                        "description": "Glob pattern for safety files",
-                    },
-                    {
-                        "type": "array",
-                        "items": {"type": "string", "minLength": 1},
-                        "description": "List of glob patterns for safety files",
-                    },
-                ],
-                "description": "Glob pattern(s) for files that, if also changed, mean the policy doesn't need to trigger",
-            },
-            "instructions": {
-                "type": "string",
-                "minLength": 1,
-                "description": "Instructions to give the agent when this policy triggers",
-            },
-            "instructions_file": {
-                "type": "string",
-                "minLength": 1,
-                "description": "Path to a file containing instructions (alternative to inline instructions)",
-            },
-            "compare_to": {
-                "type": "string",
-                "enum": ["base", "default_tip", "prompt"],
-                "description": (
-                    "What to compare against when detecting changed files. "
-                    "'base' (default) compares to the base of the current branch. "
-                    "'default_tip' compares to the tip of the default branch. "
-                    "'prompt' compares to the state at the start of the prompt."
-                ),
-            },
-        },
-        "oneOf": [
-            {"required": ["instructions"]},
-            {"required": ["instructions_file"]},
-        ],
-        "additionalProperties": False,
-    },
-}

deepwork/standard_jobs/deepwork_policy/hooks/capture_prompt_work_tree.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-# capture_prompt_work_tree.sh - Captures the git work tree state at prompt submission
-#
-# This script creates a snapshot of the current git state by recording
-# all files that have been modified, added, or deleted. This baseline
-# is used for policies with compare_to: prompt to detect what changed
-# during an agent response (between user prompts).
-
-set -e
-
-# Ensure .deepwork directory exists
-mkdir -p .deepwork
-
-# Stage all changes so we can diff against HEAD
-git add -A 2>/dev/null || true
-
-# Save the current state of changed files
-# Using git diff --name-only HEAD to get the list of all changed files
-git diff --name-only HEAD > .deepwork/.last_work_tree 2>/dev/null || true
-
-# Also include untracked files not yet in the index
-git ls-files --others --exclude-standard >> .deepwork/.last_work_tree 2>/dev/null || true
-
-# Sort and deduplicate
-if [ -f .deepwork/.last_work_tree ]; then
-    sort -u .deepwork/.last_work_tree -o .deepwork/.last_work_tree
-fi

deepwork/standard_jobs/deepwork_policy/hooks/global_hooks.yml

@@ -1,8 +0,0 @@
-# DeepWork Policy Hooks Configuration
-# Maps Claude Code lifecycle events to hook scripts
-
-UserPromptSubmit:
-  - user_prompt_submit.sh
-
-Stop:
-  - policy_stop_hook.sh

deepwork/standard_jobs/deepwork_policy/hooks/policy_stop_hook.sh

@@ -1,56 +0,0 @@
-#!/bin/bash
-# policy_stop_hook.sh - Evaluates policies when the agent stops
-#
-# This script is called as a Claude Code Stop hook. It:
-# 1. Evaluates policies from .deepwork.policy.yml
-# 2. Computes changed files based on each policy's compare_to setting
-# 3. Checks for <promise> tags in the conversation transcript
-# 4. Returns JSON to block stop if policies need attention
-
-set -e
-
-# Check if policy file exists
-if [ ! -f .deepwork.policy.yml ]; then
-    # No policies defined, nothing to do
-    exit 0
-fi
-
-# Read the hook input JSON from stdin
-HOOK_INPUT=""
-if [ ! -t 0 ]; then
-    HOOK_INPUT=$(cat)
-fi
-
-# Extract transcript_path from the hook input JSON using jq
-# Claude Code passes: {"session_id": "...", "transcript_path": "...", ...}
-TRANSCRIPT_PATH=""
-if [ -n "${HOOK_INPUT}" ]; then
-    TRANSCRIPT_PATH=$(echo "${HOOK_INPUT}" | jq -r '.transcript_path // empty' 2>/dev/null || echo "")
-fi
-
-# Extract conversation text from the JSONL transcript
-# The transcript is JSONL format - each line is a JSON object
-# We need to extract the text content from assistant messages
-conversation_context=""
-if [ -n "${TRANSCRIPT_PATH}" ] && [ -f "${TRANSCRIPT_PATH}" ]; then
-    # Extract text content from all assistant messages in the transcript
-    # Each line is a JSON object; we extract .message.content[].text for assistant messages
-    conversation_context=$(cat "${TRANSCRIPT_PATH}" | \
-        grep -E '"role"\s*:\s*"assistant"' | \
-        jq -r '.message.content // [] | map(select(.type == "text")) | map(.text) | join("\n")' 2>/dev/null | \
-        tr -d '\0' || echo "")
-fi
-
-# Call the Python evaluator
-# The Python module handles:
-# - Parsing the policy file
-# - Computing changed files based on each policy's compare_to setting
-# - Matching changed files against triggers/safety patterns
-# - Checking for promise tags in the conversation context
-# - Generating appropriate JSON output
-result=$(echo "${conversation_context}" | python -m deepwork.hooks.evaluate_policies \
-    --policy-file .deepwork.policy.yml \
-    2>/dev/null || echo '{}')
-
-# Output the result (JSON for Claude Code hooks)
-echo "${result}"

deepwork/standard_jobs/deepwork_policy/job.yml

@@ -1,35 +0,0 @@
-name: deepwork_policy
-version: "0.1.0"
-summary: "Policy enforcement for AI agent sessions"
-description: |
-  Manages policies that automatically trigger when certain files change during an AI agent session.
-  Policies help ensure that code changes follow team guidelines, documentation is updated,
-  and architectural decisions are respected.
-
-  Policies are defined in a `.deepwork.policy.yml` file at the root of your project. Each policy
-  specifies:
-  - Trigger patterns: Glob patterns for files that, when changed, should trigger the policy
-  - Safety patterns: Glob patterns for files that, if also changed, mean the policy doesn't need to fire
-  - Instructions: What the agent should do when the policy triggers
-
-  Example use cases:
-  - Update installation docs when configuration files change
-  - Require security review when authentication code is modified
-  - Ensure API documentation stays in sync with API code
-  - Remind developers to update changelogs
-
-changelog:
-  - version: "0.1.0"
-    changes: "Initial version"
-
-steps:
-  - id: define
-    name: "Define Policy"
-    description: "Create or update policy entries in .deepwork.policy.yml"
-    instructions_file: steps/define.md
-    inputs:
-      - name: policy_purpose
-        description: "What guideline or constraint should this policy enforce?"
-    outputs:
-      - .deepwork.policy.yml
-    dependencies: []