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

deepwork/standard_jobs/deepwork_jobs/make_new_job.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+#
+# make_new_job.sh - Create directory structure for a new DeepWork job
+#
+# Usage: ./make_new_job.sh <job_name>
+#
+
+set -euo pipefail
+
+# Color output helpers
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+info() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+    exit 1
+}
+
+# Validate job name format
+validate_job_name() {
+    local name="$1"
+    if [[ ! "$name" =~ ^[a-z][a-z0-9_]*$ ]]; then
+        error "Invalid job name '$name'. Must be lowercase, start with a letter, and contain only letters, numbers, and underscores."
+    fi
+}
+
+# Main script
+main() {
+    if [[ $# -lt 1 ]]; then
+        echo "Usage: $0 <job_name>"
+        echo ""
+        echo "Creates the directory structure for a new DeepWork job."
+        echo ""
+        echo "Arguments:"
+        echo "  job_name    Name of the job (lowercase, underscores allowed)"
+        echo ""
+        echo "Example:"
+        echo "  $0 competitive_research"
+        exit 1
+    fi
+
+    local job_name="$1"
+    validate_job_name "$job_name"
+
+    # Determine the base path - look for .deepwork directory
+    local base_path
+    if [[ -d ".deepwork/jobs" ]]; then
+        base_path=".deepwork/jobs"
+    elif [[ -d "../.deepwork/jobs" ]]; then
+        base_path="../.deepwork/jobs"
+    else
+        # Create from current directory
+        base_path=".deepwork/jobs"
+        mkdir -p "$base_path"
+    fi
+
+    local job_path="${base_path}/${job_name}"
+
+    # Check if job already exists
+    if [[ -d "$job_path" ]]; then
+        error "Job '$job_name' already exists at $job_path"
+    fi
+
+    info "Creating job directory structure for '$job_name'..."
+
+    # Create main job directory and subdirectories
+    mkdir -p "$job_path"
+    mkdir -p "$job_path/steps"
+    mkdir -p "$job_path/hooks"
+    mkdir -p "$job_path/templates"
+
+    # Add .gitkeep files to empty directories
+    touch "$job_path/hooks/.gitkeep"
+    touch "$job_path/templates/.gitkeep"
+
+    # Create AGENTS.md file
+    cat > "$job_path/AGENTS.md" << 'EOF'
+# Job Management
+
+This folder and its subfolders are managed using the `deepwork_jobs` slash commands.
+
+## Recommended Commands
+
+- `/deepwork_jobs.define` - Create or modify the job.yml specification
+- `/deepwork_jobs.implement` - Generate step instruction files from the specification
+- `/deepwork_jobs.learn` - Improve instructions based on execution learnings
+
+## Directory Structure
+
+```
+.
+├── AGENTS.md          # This file - project context and guidance
+├── job.yml            # Job specification (created by /deepwork_jobs.define)
+├── steps/             # Step instruction files (created by /deepwork_jobs.implement)
+│   └── *.md           # One file per step
+├── hooks/             # Custom validation scripts and prompts
+│   └── *.md|*.sh      # Hook files referenced in job.yml
+└── templates/         # Example file formats and templates
+    └── *.md|*.yml     # Templates referenced in step instructions
+```
+
+## Editing Guidelines
+
+1. **Use slash commands** for structural changes (adding steps, modifying job.yml)
+2. **Direct edits** are fine for minor instruction tweaks
+3. **Run `/deepwork_jobs.learn`** after executing job steps to capture improvements
+4. **Run `deepwork sync`** after any changes to regenerate commands
+EOF
+
+    info "Created directory structure:"
+    echo "  $job_path/"
+    echo "  ├── AGENTS.md"
+    echo "  ├── steps/"
+    echo "  ├── hooks/.gitkeep"
+    echo "  └── templates/.gitkeep"
+
+    echo ""
+    info "Next steps:"
+    echo "  1. Run '/deepwork_jobs.define' to create the job.yml specification"
+    echo "  2. Run '/deepwork_jobs.implement' to generate step instructions"
+    echo "  3. Run 'deepwork sync' to create slash commands"
+}
+
+main "$@"

deepwork/standard_jobs/deepwork_jobs/steps/define.md

@@ -62,6 +62,12 @@ For each major phase they mentioned, ask detailed questions:
 
 **Note**: You're gathering this information to understand what instructions will be needed, but you won't create the instruction files yet - that happens in the `implement` step.
 
+### Capability Considerations
+
+When defining steps, identify any that require specialized tools:
+
+**Browser Automation**: If any step involves web scraping, form filling, interactive browsing, UI testing, or research requiring website visits, ask the user what browser tools they have available. For Claude Code users, **Claude in Chrome** (Anthropic's browser extension) has been tested with DeepWork and is recommended for new users. Don't assume a default—confirm the tool before designing browser-dependent steps.
+
 ### Step 3: Validate the Workflow
 
 After gathering information about all steps:
@@ -129,68 +135,31 @@ stop_hooks:
 
 **Encourage prompt-based hooks** - They leverage the AI's ability to understand context and make nuanced quality judgments. Script hooks are best for objective checks (syntax, format, tests).
 
-### Step 5: Create the job.yml Specification
+### Step 5: Create the Job Directory and Specification
 
-Only after you have complete understanding, create the `job.yml` file:
+Only after you have complete understanding, create the job directory and `job.yml` file:
 
-**File Location**: `.deepwork/jobs/[job_name]/job.yml`
+**First, create the directory structure** using the `make_new_job.sh` script:
 
-(Where `[job_name]` is the name of the NEW job you're creating, e.g., `.deepwork/jobs/competitive_research/job.yml`)
-
-**Format**:
-```yaml
-name: [job_name]
-version: "1.0.0"
-summary: "[Brief one-line summary of what this job accomplishes]"
-description: |
-  [Detailed multi-line description of the job's purpose, process, and goals.
-
-  This should explain:
-  - What problem this workflow solves
-  - What the overall process looks like
-  - What the end result will be
-  - Who the intended users are
-  - Any important context about the workflow]
-
-changelog:
-  - version: "1.0.0"
-    changes: "Initial job creation"
-
-steps:
-  - id: [step_id]
-    name: "[Step Name]"
-    description: "[What this step does]"
-    instructions_file: steps/[step_id].md
-    inputs:
-      - name: [param_name]
-        description: "[What user needs to provide]"
-      # OR for file inputs from previous steps:
-      # - file: [filename_or_path]
-      #   from_step: [previous_step_id]
-    outputs:
-      - [output_filename_or_path]  # e.g., "report.md" or "reports/analysis.md"
-    dependencies: []  # List of step IDs that must complete first
-    # Optional: Quality validation hooks
-    stop_hooks:
-      - prompt: |
-          Verify this step's output meets quality criteria:
-          1. [Criterion 1]
-          2. [Criterion 2]
-          If ALL criteria are met, include `<promise>✓ Quality Criteria Met</promise>`.
-
-  - id: [another_step]
-    name: "[Another Step]"
-    description: "[What this step does]"
-    instructions_file: steps/[another_step].md
-    inputs:
-      - file: [output_filename_or_path]
-        from_step: [step_id]
-    outputs:
-      - [another_output_path]
-    dependencies:
-      - [step_id]  # This step requires the previous step
+```bash
+.deepwork/jobs/deepwork_jobs/make_new_job.sh [job_name]
 ```
 
+This creates:
+- `.deepwork/jobs/[job_name]/` - Main job directory
+- `.deepwork/jobs/[job_name]/steps/` - For step instruction files
+- `.deepwork/jobs/[job_name]/hooks/` - For custom validation scripts
+- `.deepwork/jobs/[job_name]/templates/` - For example file formats
+- `.deepwork/jobs/[job_name]/AGENTS.md` - Job management guidance
+
+**Then create the job.yml file** at `.deepwork/jobs/[job_name]/job.yml`
+
+(Where `[job_name]` is the name of the NEW job you're creating, e.g., `competitive_research`)
+
+**Template reference**: See `.deepwork/jobs/deepwork_jobs/templates/job.yml.template` for the standard structure.
+
+**Complete example**: See `.deepwork/jobs/deepwork_jobs/templates/job.yml.example` for a fully worked example.
+
 **Important**:
 - Use lowercase with underscores for job name and step IDs
 - Ensure file inputs reference steps in dependencies

deepwork/standard_jobs/deepwork_jobs/steps/implement.md

@@ -8,10 +8,31 @@ Generate the DeepWork job directory structure and instruction files for each ste
 
 Read the `job.yml` specification file and create all the necessary files to make the job functional, including directory structure and step instruction files. Then sync the commands to make them available.
 
-### Step 1: Read and Validate the Specification
+### Step 1: Create Directory Structure Using Script
+
+Run the `make_new_job.sh` script to create the standard directory structure:
+
+```bash
+.deepwork/jobs/deepwork_jobs/make_new_job.sh [job_name]
+```
+
+This creates:
+- `.deepwork/jobs/[job_name]/` - Main job directory
+- `.deepwork/jobs/[job_name]/steps/` - Step instruction files
+- `.deepwork/jobs/[job_name]/hooks/` - Custom validation scripts (with .gitkeep)
+- `.deepwork/jobs/[job_name]/templates/` - Example file formats (with .gitkeep)
+- `.deepwork/jobs/[job_name]/AGENTS.md` - Job management guidance
+
+**Note**: If the directory already exists (e.g., job.yml was created by define step), you can skip this step or manually create the additional directories:
+```bash
+mkdir -p .deepwork/jobs/[job_name]/hooks .deepwork/jobs/[job_name]/templates
+touch .deepwork/jobs/[job_name]/hooks/.gitkeep .deepwork/jobs/[job_name]/templates/.gitkeep
+```
+
+### Step 2: Read and Validate the Specification
 
 1. **Locate the job.yml file**
-   - Read `.deepwork/jobs/[job_name]/job.yml` from the define step (Where `[job_name]` is the name of the new job that was created in the define step)
+   - Read `.deepwork/jobs/[job_name]/job.yml` from the define step
    - Parse the YAML content
 
 2. **Validate the specification**
@@ -25,83 +46,20 @@ Read the `job.yml` specification file and create all the necessary files to make
    - List of all steps with their details
    - Understand the workflow structure
 
-### Step 2: Create Directory Structure
-
-Create the job directory in `.deepwork/jobs/[job_name]/`:
-
-```bash
-mkdir -p .deepwork/jobs/[job_name]/steps
-```
-
-Files to create:
-- `.deepwork/jobs/[job_name]/job.yml`
-- `.deepwork/jobs/[job_name]/steps/[step_id].md` - One for each step
-
 ### Step 3: Generate Step Instruction Files
 
 For each step in the job.yml, create a comprehensive instruction file at `.deepwork/jobs/[job_name]/steps/[step_id].md`.
 
-Each instruction file should follow this structure:
-
-```markdown
-# [Step Name]
-
-## Objective
-
-[Clear statement of what this step accomplishes, derived from the step's description]
-
-## Task
-
-[Detailed instructions for completing this step, based on:
-- The step's purpose
-- Expected inputs and outputs
-- The job's overall context
-]
-
-### Process
-
-[Break down the step into substeps. Use the information gathered during define about:
-- What needs to be done
-- What makes a good output
-- Any quality criteria
-]
+**Template reference**: See `.deepwork/jobs/deepwork_jobs/templates/step_instruction.md.template` for the standard structure.
 
-1. [Substep 1]
-2. [Substep 2]
-3. [Substep 3]
+**Complete example**: See `.deepwork/jobs/deepwork_jobs/templates/step_instruction.md.example` for a fully worked example.
 
-[If this step has user inputs, explain how to gather them]
-[If this step has file inputs, explain how to use them]
-
-## Output Format
-
-### [output_filename_1]
-
-[Description of what should be in this output file]
-
-**Structure**:
-```[file format]
-[Example or template of what the output should look like]
-```
-
-[Repeat for each output file]
-
-## Quality Criteria
-
-[List what makes this step's output high quality:
-- Completeness checks
-- Format requirements
-- Content requirements
-]
-
-- [Quality criterion 1]
-- [Quality criterion 2]
-- [Quality criterion 3]
-
-## Context
-
-[Provide context from the job's overall description to help understand why this step matters and how it fits into the bigger picture]
-```
+**Available templates in `.deepwork/jobs/deepwork_jobs/templates/`:**
+- `job.yml.template` - Job specification structure
+- `step_instruction.md.template` - Step instruction file structure
+- `agents.md.template` - AGENTS.md file structure
+- `job.yml.example` - Complete job specification example
+- `step_instruction.md.example` - Complete step instruction example
 
 **Guidelines for generating instructions:**
 
@@ -144,6 +102,12 @@ If a step in the job.yml has `stop_hooks` defined, the generated instruction fil
 
 This alignment ensures the AI agent knows exactly what will be validated and can self-check before completing.
 
+### Using Supplementary Reference Files
+
+Step instructions can include additional `.md` files in the `steps/` directory for detailed examples, templates, or reference material. Reference them using the full path from the project root.
+
+See `.deepwork/jobs/deepwork_jobs/steps/supplemental_file_references.md` for detailed documentation and examples.
+
 ### Step 4: Verify job.yml Location
 
 Verify that `job.yml` is in the correct location at `.deepwork/jobs/[job_name]/job.yml`. The define step should have created it there. If for some reason it's not there, you may need to create or move it.
@@ -161,11 +125,9 @@ This will:
 - Generate slash-commands for each step
 - Make the commands available in `.claude/commands/` (or appropriate platform directory)
 
-### Step 6: Reload Commands
+### Step 6: Relay Reload Instructions
 
-Instruct the user to reload commands in their current session:
-- Run `/reload` command (if available)
-- Or restart the Claude session
+After running `deepwork sync`, look at the "To use the new commands" section in the output. **Relay these exact reload instructions to the user** so they know how to pick up the new commands. Don't just reference the sync output - tell them directly what they need to do (e.g., "Type 'exit' then run 'claude --resume'" for Claude Code, or "Run '/memory refresh'" for Gemini CLI).
 
 ### Step 7: Consider Policies for the New Job
 
@@ -229,112 +191,9 @@ Would you like me to create this policy? I can run `/deepwork_policy.define` to
 
 ## Example Implementation
 
-**Given this job.yml:**
-```yaml
-name: competitive_research
-version: "1.0.0"
-summary: "Systematic competitive analysis workflow"
-description: |
-  A comprehensive workflow for analyzing competitors in your market segment.
-  Helps product teams understand the competitive landscape through systematic
-  identification, research, comparison, and positioning recommendations.
-
-steps:
-  - id: identify_competitors
-    name: "Identify Competitors"
-    description: "Identify 5-7 key competitors in the target market"
-    instructions_file: steps/identify_competitors.md
-    inputs:
-      - name: market_segment
-        description: "The market segment to analyze"
-      - name: product_category
-        description: "The product category"
-    outputs:
-      - competitors_list.md
-    dependencies: []
-```
-
-**Generate this instruction file** (`.deepwork/jobs/competitive_research/steps/identify_competitors.md`):
-
-```markdown
-# Identify Competitors
-
-## Objective
-
-Identify 5-7 key competitors in the target market segment to analyze for competitive positioning.
-
-## Task
-
-Research and identify the most relevant competitors in the specified market segment and product category. Focus on companies that directly compete for the same customer base and solve similar problems.
-
-### Process
-
-1. **Understand the market context**
-   - Review the market segment provided by the user
-   - Understand the product category boundaries
-   - Consider direct and indirect competitors
-
-2. **Research competitors**
-   - Search for companies in this space
-   - Look for market leaders and emerging players
-   - Consider different competitive dimensions (features, price, target market)
-
-3. **Select 5-7 key competitors**
-   - Prioritize direct competitors
-   - Include at least one market leader
-   - Include 1-2 emerging/innovative players
-   - Ensure diversity in the competitive set
-
-4. **Document each competitor**
-   - Company name
-   - Brief description (2-3 sentences)
-   - Why they're a relevant competitor
-   - Primary competitive dimension
-
-## Output Format
-
-### competitors_list.md
-
-A markdown document listing each competitor with context.
-
-**Structure**:
-```markdown
-# Competitor Analysis: [Market Segment]
-
-## Market Context
-- **Segment**: [market segment]
-- **Category**: [product category]
-- **Analysis Date**: [current date]
-
-## Identified Competitors
-
-### 1. [Competitor Name]
-**Description**: [2-3 sentence description of what they do]
-
-**Why Relevant**: [Why they're a key competitor in this space]
-
-**Competitive Dimension**: [What they compete on - e.g., price, features, market segment]
-
-[Repeat for each competitor, 5-7 total]
-
-## Selection Rationale
-
-[Brief paragraph explaining why these specific competitors were chosen and what dimensions of competition they represent]
-```
-
-## Quality Criteria
-
-- 5-7 competitors identified (not too few, not too many)
-- Mix of established and emerging players
-- All competitors are genuinely relevant to the market segment
-- Each competitor has clear, specific description
-- Selection rationale explains the competitive landscape
-- Output is well-formatted and ready for use by next step
-
-## Context
-
-This is the foundation step for competitive analysis. The competitors identified here will be deeply researched in subsequent steps, so it's important to choose the right set. Focus on competitors that will provide strategic insights for positioning decisions.
-```
+For a complete worked example showing a job.yml and corresponding step instruction file, see:
+- **Job specification**: `.deepwork/jobs/deepwork_jobs/templates/job.yml.example`
+- **Step instruction**: `.deepwork/jobs/deepwork_jobs/templates/step_instruction.md.example`
 
 ## Important Guidelines
 
@@ -353,63 +212,6 @@ Before running `deepwork sync`, verify:
 - All step instruction files exist (one per step)
 - No file system errors
 
-## Output Format
-
-### implementation_summary.md
-
-After successful implementation, create a summary:
-
-```markdown
-# Job Implementation Complete: [job_name]
-
-## Overview
-
-Successfully implemented the **[job_name]** workflow with [N] steps.
-
-**Summary**: [job summary]
-
-**Version**: [version]
-
-## Files Created
-
-### Job Definition
-- `.deepwork/jobs/[job_name]/job.yml`
-
-### Step Instructions
-- `.deepwork/jobs/[job_name]/steps/[step1_id].md`
-- `.deepwork/jobs/[job_name]/steps/[step2_id].md`
-[... list all step files ...]
-
-
-## Generated Commands
-
-After running `deepwork sync`, the following slash-commands are now available:
-
-- `/[job_name].[step1_id]` - [step description]
-- `/[job_name].[step2_id]` - [step description]
-[... list all commands ...]
-
-## Next Steps
-
-1. **Reload commands**: Run `/reload` or restart your Claude session
-2. **Start the workflow**: Run `/[job_name].[first_step_id]` to begin
-3. **Test the job**: Try executing the first step to ensure everything works
-
-## Job Structure
-
-[Show the workflow diagram with step names and dependencies]
-
-Step 1: [step_name]
-  ↓
-Step 2: [step_name]
-  ↓
-Step 3: [step_name]
-  ↓
-[Final output]
-
-The job is now ready for use!
-```
-
 ## Completion Checklist
 
 Before marking this step complete, ensure:
@@ -418,8 +220,7 @@ Before marking this step complete, ensure:
 - [ ] Each instruction file is complete and actionable
 - [ ] `deepwork sync` executed successfully
 - [ ] Commands generated in platform directory
-- [ ] User informed of next steps (reload commands)
-- [ ] implementation_summary.md created
+- [ ] User informed to follow reload instructions from `deepwork sync`
 - [ ] Considered whether policies would benefit this job (Step 7)
 - [ ] If policies suggested, offered to run `/deepwork_policy.define`