Skip to content

notque/vexjoy-agent / skills/process/workflow

workflow

Verified

Structured work: multi-phase tasks, feature builds, planning, objective loops, hill climbing.

FileKindSize
SKILL.mdskill md13.2 KB
references/adr-template.mdmarkdown9.4 KB
references/agent-upgrade.mdmarkdown12.5 KB
references/article-evaluation-pipeline.mdmarkdown8.9 KB
references/article-evaluation-pipeline/references/report-template.mdmarkdown2.5 KB
references/article-evaluation-pipeline/references/wabi-sabi-classification.mdmarkdown2.4 KB
references/auto-pipeline.mdmarkdown12.5 KB
references/auto-pipeline/references/pipeline-catalog.jsonconfig15.0 KB
references/auto-pipeline/references/pipeline-catalog.mdmarkdown4.3 KB
references/build_dag.pyscript12.5 KB
references/chain-composer.mdmarkdown20.4 KB
references/chain-composer/references/canonical-chains.mdmarkdown13.9 KB
references/comprehensive-review-workflow.jsscript19.3 KB
references/comprehensive-review.mdmarkdown27.8 KB
references/comprehensive-review/references/output-templates.mdmarkdown10.6 KB
references/comprehensive-review/references/wave-0-per-package.mdmarkdown5.6 KB
references/comprehensive-review/references/wave-1-foundation.mdmarkdown10.4 KB
references/comprehensive-review/references/wave-2-deep-dive.mdmarkdown7.3 KB
references/comprehensive-review/references/wave-3-adversarial.mdmarkdown7.4 KB
references/dag-compatibility-matrix.mdmarkdown13.0 KB
references/dag-composition-patterns.mdmarkdown5.0 KB
references/dag-orchestration-advanced.mdmarkdown6.3 KB
references/dag-orchestration-examples.mdmarkdown11.4 KB
references/dag-skill-patterns.mdmarkdown12.5 KB
references/de-ai-pipeline.jsscript14.6 KB
references/de-ai-pipeline.mdmarkdown6.3 KB
references/discover_skills.pyscript12.1 KB
references/do-perspectives.mdmarkdown11.5 KB
references/doc-pipeline.mdmarkdown9.2 KB
references/domain-research.mdmarkdown32.8 KB
references/domain-research/references/task-type-guide.mdmarkdown11.4 KB
references/explore-pipeline.jsscript18.6 KB
references/explore-pipeline.mdmarkdown15.0 KB
references/fan-out-workflow.jsscript9.7 KB
references/fan-out-workflow.pyscript10.4 KB
references/feedback-loop-construction.mdmarkdown14.3 KB
references/fl-design.mdmarkdown9.6 KB
references/fl-error-handling.mdmarkdown8.5 KB
references/fl-implement.mdmarkdown7.6 KB
references/fl-pipeline.mdmarkdown6.0 KB
references/fl-plan.mdmarkdown11.0 KB
references/fl-release.mdmarkdown3.8 KB
references/fl-shared.mdmarkdown3.6 KB
references/fl-validate.mdmarkdown4.5 KB
references/github-profile-rules.mdmarkdown10.5 KB
references/github-profile-rules/references/rule-categories.mdmarkdown6.5 KB
references/hc-SPEC.mdmarkdown3.3 KB
references/hc-domain-playbooks.mdmarkdown15.4 KB
references/hc-ledger.mdmarkdown3.3 KB
references/hc-profiling-tools.mdmarkdown3.7 KB
references/hill-climb.mdmarkdown9.3 KB
references/hook-development-pipeline.mdmarkdown12.9 KB
references/mcp-pipeline-builder.mdmarkdown16.3 KB
references/mcp-pipeline-builder/references/analysis-checklist.mdmarkdown6.2 KB
references/mcp-pipeline-builder/references/design-rules.mdmarkdown7.1 KB
references/mcp-pipeline-builder/references/evaluation-guide.mdmarkdown7.6 KB
references/mcp-pipeline-builder/references/python-scaffold-template.mdmarkdown9.5 KB
references/mcp-pipeline-builder/references/ts-scaffold-template.mdmarkdown1.6 KB
references/mcp-pipeline-builder/scripts/assemble-scaffold.pyscript6.3 KB
references/mcp-pipeline-builder/scripts/register_mcp.pyscript6.9 KB
references/mcp-pipeline-builder/templates/client-cli.ts.tmplother682 B
references/mcp-pipeline-builder/templates/client-http.ts.tmplother1.4 KB
references/mcp-pipeline-builder/templates/index.ts.tmplother1.1 KB
references/mcp-pipeline-builder/templates/package.json.tmplother477 B
references/mcp-pipeline-builder/templates/readme.md.tmplother1.1 KB
references/mcp-pipeline-builder/templates/tools.ts.tmplother3.0 KB
references/mcp-pipeline-builder/templates/ts-scaffold.tmplother556 B
references/mcp-pipeline-builder/templates/tsconfig.json.tmplother408 B
references/ol-SPEC.mdmarkdown2.4 KB
references/ol-state-file.mdmarkdown2.9 KB
references/pipeline-index.jsonconfig23.9 KB
references/pipeline-orchestrator.mdmarkdown15.3 KB
references/pipeline-orchestrator/orchestration-patterns.mdmarkdown8.1 KB
references/pipeline-orchestrator/preferred-patterns.mdmarkdown4.6 KB
references/pipeline-retro.mdmarkdown19.0 KB
references/pipeline-scaffolder.mdmarkdown22.4 KB
references/pipeline-scaffolder/references/architecture-rules.mdmarkdown18.9 KB
references/pipeline-scaffolder/references/generated-skill-template.mdmarkdown1.9 KB
references/pipeline-scaffolder/references/pipeline-spec-format.mdmarkdown36.8 KB
references/pipeline-scaffolder/references/step-menu.mdmarkdown21.5 KB
references/pipeline-scaffolder/scripts/assemble-skill.pyscript6.3 KB
references/pipeline-scaffolder/templates/phases/decision-planning.md.tmplother1.2 KB
references/pipeline-scaffolder/templates/phases/domain-extension.md.tmplother1.5 KB
references/pipeline-scaffolder/templates/phases/generation.md.tmplother427 B
references/pipeline-scaffolder/templates/phases/git-release.md.tmplother1.1 KB
references/pipeline-scaffolder/templates/phases/interaction.md.tmplother965 B
references/pipeline-scaffolder/templates/phases/learning-retro.md.tmplother1.5 KB
references/pipeline-scaffolder/templates/phases/observation.md.tmplother1.3 KB
references/pipeline-scaffolder/templates/phases/research-gathering.md.tmplother1.2 KB
references/pipeline-scaffolder/templates/phases/review.md.tmplother930 B
references/pipeline-scaffolder/templates/phases/safety-guarding.md.tmplother1.7 KB
references/pipeline-scaffolder/templates/phases/structuring.md.tmplother361 B
references/pipeline-scaffolder/templates/phases/synthesis-reporting.md.tmplother1.9 KB
references/pipeline-scaffolder/templates/phases/validation.md.tmplother1.1 KB
references/pipeline-scaffolder/templates/skill-template.md.tmplother12.0 KB
references/pipeline-test-runner.mdmarkdown16.7 KB
references/pl-ambiguity-triage.mdmarkdown2.7 KB
references/pl-check-dimensions.mdmarkdown7.4 KB
references/pl-check-errors.mdmarkdown824 B
references/pl-check-verdict-format.mdmarkdown3.2 KB
references/pl-check.mdmarkdown6.5 KB
references/pl-context-boundary.mdmarkdown1.6 KB
references/pl-depth-first-interview.mdmarkdown11.6 KB
references/pl-empirical-prototype.mdmarkdown825 B
references/pl-executor-ready-plan-template.mdmarkdown7.7 KB
references/pl-human-source-elicitation.mdmarkdown1.5 KB
references/pl-manage.mdmarkdown5.1 KB
references/pl-pause-confirm-and-errors.mdmarkdown2.1 KB
references/pl-pause-extract-decisions.mdmarkdown3.0 KB
references/pl-pause-gather-steps.mdmarkdown2.3 KB
references/pl-pause-synthesize-fields.mdmarkdown2.3 KB
references/pl-pause-write-templates.mdmarkdown5.3 KB
references/pl-pause.mdmarkdown6.5 KB
references/pl-plan-files.mdmarkdown8.4 KB
references/pl-pre-plan.mdmarkdown11.6 KB
references/pl-resume.mdmarkdown12.3 KB
references/pl-spec.mdmarkdown5.2 KB
references/pr-fix-loop.mdmarkdown10.3 KB
references/pr-fix-loop/references/message-formats.mdmarkdown1.6 KB
references/pr-fix-loop/references/publish.mdmarkdown5.4 KB
references/pr-fix-loop/references/review-checklist.mdmarkdown3.4 KB
references/pr-pipeline/references/pr-templates.mdmarkdown5.4 KB
references/pr-pipeline/references/preflight-checklist.mdmarkdown2.8 KB
references/pr-pipeline/references/retro-adr-phases.mdmarkdown2.7 KB
references/pr-pipeline/references/review-fix-loop.mdmarkdown2.0 KB
references/project-coordinator.mdmarkdown6.5 KB
references/project-coordinator/agent-capability-map.mdmarkdown5.4 KB
references/project-coordinator/communication-protocols.mdmarkdown4.5 KB
references/project-coordinator/coordination-playbook.mdmarkdown3.7 KB
references/project-coordinator/death-loop-prevention.mdmarkdown3.6 KB
references/project-coordinator/error-catalog.mdmarkdown2.7 KB
references/project-coordinator/parallel-execution-patterns.mdmarkdown2.8 KB
references/project-coordinator/preferred-patterns.mdmarkdown5.9 KB
references/project-coordinator/todowrite-integration.mdmarkdown5.6 KB
references/research-pipeline.jsscript15.2 KB
references/skill-creation-pipeline.mdmarkdown17.1 KB
references/system-upgrade.mdmarkdown12.8 KB
references/systematic-debugging.mdmarkdown11.0 KB
references/systematic-refactoring.mdmarkdown11.4 KB
references/toolkit-improvement.jsscript39.0 KB
references/toolkit-improvement.mdmarkdown20.5 KB
references/toolkit-improvement/references/adr-template.mdmarkdown10.5 KB
references/toolkit-improvement/references/agent-roster.mdmarkdown15.8 KB
references/workflow-helpers.jsscript12.1 KB
references/workflow-orchestrator.mdmarkdown20.8 KB
references/workflow-orchestrator/references/plan-template.mdmarkdown1.3 KB
references/workflow-orchestrator/references/task-patterns.mdmarkdown23.3 KB
references/workflow-orchestrator/scripts/assemble-plan.pyscript6.9 KB
references/workflow-orchestrator/scripts/validate.pyscript14.4 KB
references/workflow-orchestrator/templates/plan-template.json.tmplother904 B

references/build_dag.py

View on GitHub
#!/usr/bin/env python3
"""
DAG builder for skill composition.
Analyzes tasks and creates execution directed acyclic graphs.
"""

import argparse
import json
import sys
from pathlib import Path
from typing import Any, Dict, List


class DAGBuildError(Exception):
    """DAG building related errors."""

    pass


class SkillDAGBuilder:
    """Build execution DAG from task and skill index."""

    def __init__(self, skill_index: Dict[str, Any]):
        self.skill_index = skill_index
        self.skill_map = skill_index["skill_map"]

    def analyze_task(self, task_description: str) -> Dict[str, Any]:
        """Analyze task to identify required skills."""
        task_lower = task_description.lower()

        analysis = {
            "primary_goals": [],
            "quality_requirements": [],
            "domain_hints": [],
            "execution_hints": [],
        }

        # Identify primary goals
        if any(word in task_lower for word in ["add", "implement", "create", "build"]):
            analysis["primary_goals"].append("implementation")
        if any(word in task_lower for word in ["fix", "debug", "resolve", "repair"]):
            analysis["primary_goals"].append("debugging")
        if any(word in task_lower for word in ["analyze", "review", "examine", "investigate"]):
            analysis["primary_goals"].append("analysis")
        if any(word in task_lower for word in ["document", "comment", "explain"]):
            analysis["primary_goals"].append("documentation")

        # Identify quality requirements
        if any(word in task_lower for word in ["test", "tested", "testing"]):
            analysis["quality_requirements"].append("testing")
        if any(word in task_lower for word in ["verify", "validation", "check"]):
            analysis["quality_requirements"].append("verification")
        if any(word in task_lower for word in ["quality", "lint", "style"]):
            analysis["quality_requirements"].append("quality_checks")

        # Identify domain hints
        if "go" in task_lower or "golang" in task_lower:
            analysis["domain_hints"].append("golang")
        if any(word in task_lower for word in ["pr", "pull request", "review"]):
            analysis["domain_hints"].append("pr_review")
        if "workflow" in task_lower or "orchestrat" in task_lower:
            analysis["domain_hints"].append("workflow")

        # Identify execution hints
        if "and" in task_lower or "," in task_description:
            analysis["execution_hints"].append("multiple_steps")
        if any(word in task_lower for word in ["then", "after", "before"]):
            analysis["execution_hints"].append("sequential")
        if any(word in task_lower for word in ["also", "parallel", "simultaneously"]):
            analysis["execution_hints"].append("parallel")

        return analysis

    def select_skills(self, task_analysis: Dict[str, Any]) -> List[str]:
        """Select applicable skills based on task analysis."""
        selected = []

        # Map analysis to skill categories
        category_map = {
            "implementation": ["workflow", "testing"],
            "debugging": ["debugging"],
            "analysis": ["code-analysis"],
            "documentation": ["documentation"],
            "testing": ["testing"],
            "verification": ["quality"],
            "quality_checks": ["quality"],
        }

        # Collect applicable categories
        applicable_categories = set()
        for goal in task_analysis["primary_goals"]:
            applicable_categories.update(category_map.get(goal, []))
        for req in task_analysis["quality_requirements"]:
            applicable_categories.update(category_map.get(req, []))

        # Select skills from applicable categories
        categories = self.skill_index.get("categories", {})
        for category in applicable_categories:
            if category in categories:
                selected.extend(categories[category])

        # Remove duplicates while preserving order
        seen = set()
        unique_selected = []
        for skill in selected:
            if skill not in seen:
                seen.add(skill)
                unique_selected.append(skill)

        return unique_selected

    def build_dependency_graph(self, selected_skills: List[str]) -> Dict[str, List[str]]:
        """Build dependency graph from selected skills."""
        graph = {}

        for skill_name in selected_skills:
            skill = self.skill_map.get(skill_name)
            if not skill:
                continue

            # Get dependencies that are also selected
            deps = skill.get("dependencies", [])
            applicable_deps = [d for d in deps if d in selected_skills]

            if applicable_deps:
                graph[skill_name] = applicable_deps

        return graph

    def topological_sort(self, skills: List[str], dependencies: Dict[str, List[str]]) -> List[str]:
        """Perform topological sort on skills."""
        # Build in-degree map
        in_degree = {skill: 0 for skill in skills}
        for skill, deps in dependencies.items():
            for dep in deps:
                if dep in in_degree:
                    in_degree[skill] += 1

        # Find skills with no dependencies
        queue = [skill for skill, degree in in_degree.items() if degree == 0]
        result = []

        while queue:
            # Process skill with no remaining dependencies
            skill = queue.pop(0)
            result.append(skill)

            # Reduce in-degree for dependent skills
            for dependent, deps in dependencies.items():
                if skill in deps:
                    in_degree[dependent] -= 1
                    if in_degree[dependent] == 0:
                        queue.append(dependent)

        # Check if all skills were processed (DAG is valid)
        if len(result) != len(skills):
            unprocessed = set(skills) - set(result)
            raise DAGBuildError(f"Circular dependency detected. Unprocessed skills: {unprocessed}")

        return result

    def identify_parallel_phases(
        self, sorted_skills: List[str], dependencies: Dict[str, List[str]]
    ) -> List[Dict[str, Any]]:
        """Identify which skills can run in parallel."""
        phases = []
        remaining = set(sorted_skills)
        processed = set()

        while remaining:
            # Find skills with all dependencies satisfied
            ready = []
            for skill in remaining:
                deps = dependencies.get(skill, [])
                if all(dep in processed for dep in deps):
                    ready.append(skill)

            if not ready:
                raise DAGBuildError(f"Cannot determine next phase. Remaining: {remaining}")

            # Create phase
            phase = {
                "phase": len(phases) + 1,
                "parallel": len(ready) > 1,
                "skills": ready,
            }
            phases.append(phase)

            # Update state
            remaining -= set(ready)
            processed.update(ready)

        return phases

    def build_dag(self, task_description: str) -> Dict[str, Any]:
        """Build complete execution DAG from task."""
        # Step 1: Analyze task
        task_analysis = self.analyze_task(task_description)

        # Step 2: Select applicable skills
        selected_skills = self.select_skills(task_analysis)

        if not selected_skills:
            raise DAGBuildError(f"No applicable skills found for task: {task_description}")

        # Step 3: Build dependency graph
        dependencies = self.build_dependency_graph(selected_skills)

        # Step 4: Topological sort
        sorted_skills = self.topological_sort(selected_skills, dependencies)

        # Step 5: Identify parallel execution opportunities
        phases = self.identify_parallel_phases(sorted_skills, dependencies)

        # Build final DAG
        dag = {
            "task": task_description,
            "task_analysis": task_analysis,
            "selected_skills": selected_skills,
            "dependencies": dependencies,
            "execution_order": sorted_skills,
            "phases": phases,
            "total_phases": len(phases),
            "parallel_phases": sum(1 for p in phases if p["parallel"]),
        }

        return dag


def detect_cycles(graph: Dict[str, List[str]]) -> List[List[str]]:
    """Detect cycles in dependency graph using DFS."""
    cycles = []
    visited = set()
    rec_stack = []

    def dfs(node: str, path: List[str]):
        if node in rec_stack:
            # Found cycle
            cycle_start = rec_stack.index(node)
            cycle = rec_stack[cycle_start:] + [node]
            cycles.append(cycle)
            return

        if node in visited:
            return

        visited.add(node)
        rec_stack.append(node)

        for neighbor in graph.get(node, []):
            dfs(neighbor, path + [neighbor])

        rec_stack.pop()

    for node in graph:
        if node not in visited:
            dfs(node, [node])

    return cycles


def format_dag_output(dag: Dict[str, Any]) -> str:
    """Format DAG for human-readable display."""
    lines = [
        "=" * 60,
        "EXECUTION DAG",
        "=" * 60,
        "",
        f"Task: {dag['task']}",
        "",
        "Task Analysis:",
        f"  Primary goals: {', '.join(dag['task_analysis']['primary_goals'])}",
        f"  Quality requirements: {', '.join(dag['task_analysis']['quality_requirements'])}",
        "",
        f"Selected Skills ({len(dag['selected_skills'])}): {', '.join(dag['selected_skills'])}",
        "",
        "Execution Plan:",
        "",
    ]

    for phase in dag["phases"]:
        parallel_marker = " (PARALLEL)" if phase["parallel"] else ""
        lines.append(f"Phase {phase['phase']}{parallel_marker}:")
        for skill in phase["skills"]:
            lines.append(f"  → {skill}")
        lines.append("")

    lines.extend(
        [
            "Summary:",
            f"  Total phases: {dag['total_phases']}",
            f"  Parallel phases: {dag['parallel_phases']}",
            f"  Skills: {len(dag['selected_skills'])}",
            "=" * 60,
        ]
    )

    return "\n".join(lines)


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(description="Build execution DAG from task and skill index")
    parser.add_argument("--task", type=str, required=True, help="Task description")
    parser.add_argument("--skill-index", type=Path, required=True, help="Path to skill index JSON")
    parser.add_argument("--output", type=Path, required=True, help="Output DAG JSON file")
    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")

    args = parser.parse_args()

    try:
        # Load skill index
        if not args.skill_index.exists():
            raise DAGBuildError(f"Skill index not found: {args.skill_index}")

        with open(args.skill_index, "r", encoding="utf-8") as f:
            skill_index = json.load(f)

        # Build DAG
        print(f"Analyzing task: {args.task}", file=sys.stderr)
        builder = SkillDAGBuilder(skill_index)
        dag = builder.build_dag(args.task)

        # Check for cycles
        cycles = detect_cycles(dag["dependencies"])
        if cycles:
            cycle_strs = [" → ".join(cycle) for cycle in cycles]
            raise DAGBuildError("Circular dependencies detected:\n" + "\n".join(cycle_strs))

        # Write output
        args.output.parent.mkdir(parents=True, exist_ok=True)
        with open(args.output, "w", encoding="utf-8") as f:
            json.dump(dag, f, indent=2, ensure_ascii=False)

        print(f"\nDAG written to: {args.output}", file=sys.stderr)

        # Print formatted DAG
        print("\n" + format_dag_output(dag), file=sys.stderr)

        # Output success to stdout
        print(
            json.dumps(
                {
                    "status": "success",
                    "total_phases": dag["total_phases"],
                    "skills": len(dag["selected_skills"]),
                    "output_file": str(args.output),
                },
                indent=2,
            )
        )

    except DAGBuildError as e:
        print(
            json.dumps(
                {"status": "error", "error_type": "DAGBuildError", "message": str(e)},
                indent=2,
            ),
            file=sys.stderr,
        )
        sys.exit(1)
    except Exception as e:
        print(
            json.dumps(
                {"status": "error", "error_type": type(e).__name__, "message": str(e)},
                indent=2,
            ),
            file=sys.stderr,
        )
        sys.exit(2)


if __name__ == "__main__":
    main()
planning-and-task-breakdownaddyosmani/agent-skillsBreaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
screenpipethedotmack/claude-memSearch screen and audio history recorded by Screenpipe and optionally save selected context into claude-mem. Use when the user asks to recall desktop activity, a meeting, or something seen in another app through Screenpipe.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
contact-widgetnexu-io/open-designSelf-contained floating chat widget with welcome screen, social links, meeting button, and message input. Single HTML file, zero dependencies.Stars: 108kUpdated Claude CodeCodexVerifiedInstall
meeting-notesnexu-io/open-designMeeting notes page — title bar with attendees, agenda checklist, decisions block, action items table with owners + dates, and a "next meeting" footer. Use when the brief mentions "meeting notes", "minutes", "1:1 notes", "all-hands recap", or "会议纪要".Stars: 108kUpdated Claude CodeCodexVerifiedInstall