home / skills / shotaiuchi / dotclaude / sh1-create

sh1-create skill

safe

This skill helps you create and manage batch workflow schedules with dependency analysis, enabling prioritization checks and reliable execution planning.

npx playbooks add skill shotaiuchi/dotclaude --skill sh1-create

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.5 KB

---
name: sh1-create
description: バッチワークフロー実行のスケジュール管理
argument-hint: "<create | show | edit | validate | clear> [args...]"
---

**Always respond in Japanese.**

# /sh1-create

Create and manage workflow schedules with dependency analysis.

## Usage

```
/sh1-create <subcommand> [arguments...]
```

## Subcommands

| Subcommand | Description |
|------------|-------------|
| `create [sources...]` | Create schedule from specified sources |
| `show` | Display current schedule |
| `edit [work-id]` | Edit priority or dependencies |
| `validate` | Validate schedule (circular dependency check) |
| `clear` | Delete current schedule |

## Source Specification

```bash
# GitHub Issues (by label or milestone)
/sh1-create create github="label:scheduled"
/sh1-create create github="milestone:v1.0"

# Jira (by JQL)
/sh1-create create jira="project=PROJ AND sprint=current"

# Local works (comma-separated)
/sh1-create create local=FEAT-001,FIX-002

# Combined / All from config
/sh1-create create github="label:scheduled" jira="sprint=current"
/sh1-create create --all
```

## Processing

### create

1. Fetch issues from specified sources
2. Generate work-ids for each
3. Detect dependencies from issue body text (patterns: `depends on #N`, `blocked by #N`, `requires PROJ-N`, `after: WORK-ID`)
4. Check for circular dependencies
5. Assign priorities (configurable via `config.json` `batch.dependency_patterns`)
6. Save to `.wf/schedule.json`

### show

Display: status, created date, progress (completed/in_progress/pending), works sorted by priority with deps.

### edit

Edit priority (`priority=<1-10>`) or dependencies (`depends=<ids>`, `remove-dep=<id>`) for a work.

### validate

Check: circular dependencies, unresolved dependency references, priority conflicts.

### clear

Delete `.wf/schedule.json` with confirmation.

## Schedule JSON Schema

```json
{
  "version": "1.0",
  "created_at": "<timestamp>",
  "status": "pending|running|paused|completed",
  "sources": [{"type": "github", "query": "label:scheduled"}],
  "works": {
    "<work-id>": {
      "source": {"type": "github", "id": "123", "title": "..."},
      "priority": 1,
      "dependencies": ["<other-work-id>"],
      "status": "pending|running|completed|failed",
      "started_at": null,
      "completed_at": null
    }
  },
  "progress": { "total": 5, "completed": 0, "in_progress": 0, "pending": 5 }
}
```

## Notes

- Requires `gh` for GitHub, `jq` for JSON
- Schedule stored in `.wf/schedule.json`
- Works processed in priority order respecting dependencies

Overview

This skill creates and manages batch workflow schedules with automatic dependency analysis and validation. It collects work items from GitHub, Jira, or local lists, detects dependencies in issue text, assigns priorities, and saves a deterministic schedule file. The schedule is stored as .wf/schedule.json and can be shown, edited, validated, or cleared from the command line. It is designed for straightforward, repeatable batch-run orchestration in shell environments.

How this skill works

The command fetches issues from configured sources (GitHub via gh, Jira via JQL, or local IDs), generates consistent work IDs, and scans bodies for dependency patterns (e.g., "depends on #N", "requires PROJ-N", "after: WORK-ID"). It builds a schedule JSON with works, priorities, dependencies, and progress, then checks for circular or unresolved dependencies and records the result. You can view the schedule, edit priorities or dependencies for specific works, validate integrity, or delete the schedule file with confirmation.

When to use it

When you need a single, consistent batch schedule assembled from issues across GitHub, Jira, and local lists.
Before running a batch workflow to ensure dependencies and priorities are valid and non-circular.
To export or inspect a machine-readable schedule (.wf/schedule.json) for automation or reporting.
When resolving dependency or priority conflicts across multiple tracked issues.
To quickly rebuild schedules from updated labels, milestones, or JQL queries.

Best practices

Keep dependency mentions consistent in issue bodies using the supported patterns for reliable detection.
Run validate after creating or editing a schedule to catch cycles and unresolved references early.
Configure priority rules in config.json to reflect your organizational batching strategy.
Use source filters (labels, milestones, JQL) to limit schedule scope and avoid accidental inclusion.
Back up .wf/schedule.json before running destructive edits or a clear operation.

Example use cases

Create a nightly batch schedule from GitHub issues labeled 'scheduled' and save it for the runner.
Aggregate current sprint work from Jira and local hotfix IDs into a single dependency-aware schedule.
Show the current schedule to stakeholders including progress and per-work dependencies.
Edit a work to raise its priority to unblock downstream tasks without changing the source issue.
Validate a schedule before execution to detect circular dependencies and missing references.

FAQ

What dependencies does the tool detect automatically?

It detects patterns like 'depends on #N', 'blocked by #N', 'requires PROJ-N', and 'after: WORK-ID' in issue or ticket bodies.

What external tools are required?

The skill depends on the gh CLI for GitHub and jq for JSON manipulation; Jira access uses provided JQL queries.