pactkit 1.0.0__py3-none-any.whl

pactkit/__init__.py

@@ -0,0 +1,3 @@
+"""PactKit - Spec-driven agentic DevOps toolkit."""
+
+__version__ = "1.0.0"

pactkit/cli.py

@@ -0,0 +1,78 @@
+"""PactKit CLI — Spec-driven agentic DevOps toolkit.
+
+Usage:
+    pactkit init                  # Deploy Expert mode (default)
+    pactkit init --mode common    # Deploy lightweight Common mode
+    pactkit init -t /tmp/preview  # Preview to custom directory
+    pactkit update                # Re-deploy (same as init, idempotent)
+    pactkit version               # Show version
+"""
+import argparse
+import sys
+
+from pactkit import __version__
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="pactkit",
+        description="PactKit — Spec-driven agentic DevOps toolkit",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # pactkit init
+    init_parser = subparsers.add_parser("init", help="Deploy PactKit configuration")
+    init_parser.add_argument(
+        "--mode",
+        choices=["expert", "common"],
+        default="expert",
+        help="Deployment mode: expert (full, default) or common (lightweight)",
+    )
+    init_parser.add_argument(
+        "-t", "--target",
+        type=str,
+        default=None,
+        help="Custom target directory (default: ~/.claude)",
+    )
+
+    # pactkit update (alias for init)
+    update_parser = subparsers.add_parser("update", help="Re-deploy PactKit configuration")
+    update_parser.add_argument(
+        "--mode",
+        choices=["expert", "common"],
+        default="expert",
+        help="Deployment mode: expert (full, default) or common (lightweight)",
+    )
+    update_parser.add_argument(
+        "-t", "--target",
+        type=str,
+        default=None,
+        help="Custom target directory (default: ~/.claude)",
+    )
+
+    # pactkit version
+    subparsers.add_parser("version", help="Show PactKit version")
+
+    args = parser.parse_args()
+
+    if args.command in ("init", "update"):
+        if args.mode == "expert":
+            from pactkit.generators.deployer import deploy
+            deploy()
+        else:
+            from pactkit.common_user import main as common_main
+            # Simulate CLI args for common_user
+            sys.argv = ["pactkit"]
+            if args.target:
+                sys.argv.extend(["-t", args.target])
+            common_main()
+
+    elif args.command == "version":
+        print(f"PactKit v{__version__}")
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

pactkit/common_user.py

@@ -0,0 +1,219 @@
+"""
+PactKit Common User Installer (Experience Mode)
+Standalone, self-contained, zero external dependencies.
+Generates a lightweight PDCA workflow for Claude Code.
+
+Usage:
+    pactkit init --mode common              # Install to ~/.claude/
+    pactkit init --mode common -t /tmp/out  # Preview to custom dir
+"""
+import argparse
+import textwrap
+from pathlib import Path
+
+
+# --- Configuration ---
+class Colors:
+    GREEN = '\033[92m'
+    BLUE = '\033[94m'
+    YELLOW = '\033[93m'
+    ENDC = '\033[0m'
+
+def print_success(msg): print(f"{Colors.GREEN}[SUCCESS]{Colors.ENDC} {msg}")
+def print_info(msg): print(f"{Colors.BLUE}[INFO]{Colors.ENDC} {msg}")
+def print_warn(msg): print(f"{Colors.YELLOW}[WARN]{Colors.ENDC} {msg}")
+
+def ensure_file(path: Path, content: str):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content.strip(), encoding="utf-8")
+    print_success(f"Generated: {path}")
+
+# --- Content Definitions ---
+
+def get_common_user_config():
+    """
+    Experience Mode Configuration.
+    Pure prompt injection only. No scripts, no tools, no cross-file references.
+    """
+
+    claude_md = textwrap.dedent("""\
+    # Claude Code — Lightweight PDCA
+
+    ## Core Protocol
+    - **Language**: Mirror the user's input language.
+    - **Tone**: Concise, professional, engineering-first.
+    - **Git**: Use Conventional Commits (`feat`, `fix`, `docs`, `chore`).
+
+    ## Workflow: PDCA
+    This environment follows a lightweight **Plan → Act → Check → Done** cycle:
+
+    | Step | Command | What it does |
+    |------|---------|--------------|
+    | Plan | `/plan` | Analyze the request, create a TODO list |
+    | Act  | `/act`  | Implement the next pending task |
+    | Check| `/check`| Review code quality and run tests |
+    | Done | `/done` | Summarize work and prepare a git commit |
+
+    ## Guidelines
+    - Keep plans in a `TODO.md` file at the project root.
+    - One task at a time: implement, then review, then commit.
+    - Prefer editing existing files over creating new ones.
+    """)
+
+    cmd_plan = textwrap.dedent("""\
+    ---
+    description: "Analyze requirements and create a plan"
+    ---
+
+    # Command: Plan (Lite)
+    - **Usage**: `/plan "Feature or bug description"`
+
+    ## Your Role
+    You are a Technical Lead. Analyze the user's request and create a structured plan.
+
+    ## Steps
+    1. Read the user's request carefully.
+    2. If a `TODO.md` exists at the project root, read it and update it.
+       If not, create a new `TODO.md`.
+    3. Break down the requirement into clear, checkable steps:
+       - Use `- [ ] Step description` format.
+       - Each step should be small enough to implement in one pass.
+    4. Identify which existing files will need changes.
+
+    ## Rules
+    - Do NOT write any code in this step — only plan.
+    - Do NOT create new directories or files (except `TODO.md`).
+    - Present the plan to the user for confirmation before proceeding.
+    """)
+
+    cmd_act = textwrap.dedent("""\
+    ---
+    description: "Implement the next task from the plan"
+    ---
+
+    # Command: Act (Lite)
+    - **Usage**: `/act`
+
+    ## Your Role
+    You are a Developer. Execute the next pending task from the plan.
+
+    ## Steps
+    1. Read `TODO.md` to find the first unchecked item (`- [ ]`).
+    2. Understand the relevant code context by reading the target files.
+    3. Write the code to implement this single task.
+    4. Mark the item as done: `- [x]` in `TODO.md`.
+
+    ## Rules
+    - Implement only ONE task per invocation.
+    - Prefer editing existing files over creating new ones.
+    - Stop after implementation — do not review or commit.
+    """)
+
+    cmd_check = textwrap.dedent("""\
+    ---
+    description: "Review code and run tests"
+    ---
+
+    # Command: Check (Lite)
+    - **Usage**: `/check`
+
+    ## Your Role
+    You are a Code Reviewer. Verify the quality of recent changes.
+
+    ## Steps
+    1. Review the files modified since the last commit (`git diff`).
+    2. Check for:
+       - Logic errors or obvious bugs
+       - Syntax issues
+       - Deviations from the plan in `TODO.md`
+    3. If tests exist in the project, run them.
+    4. Report findings to the user.
+
+    ## Rules
+    - Do NOT fix issues yourself — only report them.
+    - If tests fail, explain which tests failed and why.
+    - If everything looks good, say so and suggest proceeding to `/done`.
+    """)
+
+    cmd_done = textwrap.dedent("""\
+    ---
+    description: "Summarize work and prepare a git commit"
+    ---
+
+    # Command: Done (Lite)
+    - **Usage**: `/done`
+
+    ## Your Role
+    You are a Release Engineer. Wrap up the current work session.
+
+    ## Steps
+    1. Read `TODO.md` to summarize what was completed.
+    2. Review `git diff` to confirm all changes are intentional.
+    3. Generate a Conventional Commit message:
+       - Format: `type(scope): description`
+       - Types: `feat`, `fix`, `docs`, `chore`, `refactor`, `test`
+    4. Present the commit command to the user for confirmation.
+    5. After the user confirms, execute the commit.
+    6. Clean up completed items in `TODO.md` (remove or archive them).
+
+    ## Rules
+    - NEVER commit without user confirmation.
+    - NEVER push to remote unless the user explicitly asks.
+    """)
+
+    return {
+        "claude_md": claude_md,
+        "commands": {
+            "plan.md": cmd_plan,
+            "act.md": cmd_act,
+            "check.md": cmd_check,
+            "done.md": cmd_done,
+        }
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="PactKit Common User Installer (Experience Mode)")
+    parser.add_argument("-t", "--target", type=str, help="Specify target directory (default: ~/.claude)", default=None)
+    args = parser.parse_args()
+
+    if args.target:
+        claude_root = Path(args.target).resolve()
+        print_warn(f"Running in PREVIEW mode. Generating files to: {claude_root}")
+    else:
+        claude_root = Path.home() / ".claude"
+        print_info("Running in INSTALL mode. Targeting: ~/.claude")
+
+    config = get_common_user_config()
+
+    # 1. Generate CLAUDE.md (inline PDCA, no cross-file references)
+    ensure_file(claude_root / "CLAUDE.md", config["claude_md"])
+
+    # 2. Generate Commands (4 lightweight PDCA commands)
+    cmds_dir = claude_root / "commands"
+    for filename, content in config["commands"].items():
+        ensure_file(cmds_dir / filename, content)
+
+    print_info("Common User Configuration Generated!")
+
+    if args.target:
+        print(f"""
+    {Colors.YELLOW}Preview Generation Complete.{Colors.ENDC}
+    Check the '{args.target}' directory to verify the structure.
+
+    To install for real, run:
+    {Colors.GREEN}pactkit init --mode common{Colors.ENDC}
+        """)
+    else:
+        print(f"""
+    {Colors.GREEN}Your Environment is ready! (Experience Mode){Colors.ENDC}
+
+    How to use (in any project):
+    1. {Colors.BLUE}/plan "Fix login bug"{Colors.ENDC}  -> Creates TODO.md
+    2. {Colors.BLUE}/act{Colors.ENDC}                    -> Writes code
+    3. {Colors.BLUE}/check{Colors.ENDC}                  -> Reviews code
+    4. {Colors.BLUE}/done{Colors.ENDC}                   -> Commits code
+        """)
+
+if __name__ == "__main__":
+    main()

pactkit/generators/deployer.py

@@ -0,0 +1,157 @@
+import sys
+from pathlib import Path
+
+# 确保能 import pactkit.prompts
+current_dir = Path(__file__).resolve().parent
+project_root = current_dir.parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+from pactkit import prompts
+from pactkit.skills import load_script
+from pactkit.utils import atomic_write
+
+
+def deploy(mode="expert"):
+    print("🚀 PactKit DevOps Deployment (v20.0 - EXPERT Mode)")
+
+    # 1. 准备目录
+    claude_root = Path.home() / ".claude"
+    agents_dir = claude_root / "agents"
+    commands_dir = claude_root / "commands"
+    skills_dir = claude_root / "skills"
+
+    for d in [claude_root, agents_dir, commands_dir, skills_dir]:
+        d.mkdir(parents=True, exist_ok=True)
+
+    # 2. 部署 Skills (v20.0 Compliant Skill Structure)
+    _deploy_skills(skills_dir)
+
+    # 3. 清理旧文件
+    _cleanup_legacy(skills_dir)
+
+    # 4. 部署 Expert 配置
+    _deploy_expert(claude_root, agents_dir, commands_dir)
+
+    print("\n🎉 Deployment Complete.")
+
+
+def _deploy_skills(skills_dir):
+    """部署合规的 Skill 目录结构"""
+    skill_defs = [
+        {
+            'name': 'pactkit-visualize',
+            'skill_md': prompts.SKILL_VISUALIZE_MD,
+            'script_name': 'visualize.py',
+            'script_source': load_script('visualize.py'),
+        },
+        {
+            'name': 'pactkit-board',
+            'skill_md': prompts.SKILL_BOARD_MD,
+            'script_name': 'board.py',
+            'script_source': load_script('board.py'),
+        },
+        {
+            'name': 'pactkit-scaffold',
+            'skill_md': prompts.SKILL_SCAFFOLD_MD,
+            'script_name': 'scaffold.py',
+            'script_source': load_script('scaffold.py'),
+        },
+    ]
+
+    for sd in skill_defs:
+        skill_dir = skills_dir / sd['name']
+        scripts_dir = skill_dir / 'scripts'
+        scripts_dir.mkdir(parents=True, exist_ok=True)
+
+        atomic_write(skill_dir / 'SKILL.md', sd['skill_md'])
+        atomic_write(scripts_dir / sd['script_name'], sd['script_source'])
+
+    print(f"✅ Deployed {len(skill_defs)} Skills (Compliant Structure)")
+
+
+def _cleanup_legacy(skills_dir):
+    """清理旧的 pactkit_tools.py"""
+    legacy = skills_dir / 'pactkit_tools.py'
+    if legacy.exists():
+        legacy.unlink()
+        print(f"🧹 Removed legacy: {legacy}")
+
+
+def _deploy_rules(claude_root):
+    """部署模块化规则到 ~/.claude/rules/，保护用户自定义文件"""
+    rules_dir = claude_root / "rules"
+    rules_dir.mkdir(parents=True, exist_ok=True)
+
+    # 清理受管理的文件（01-04 前缀），保留用户文件（10+）
+    for f in rules_dir.glob('*.md'):
+        if any(f.name.startswith(p) for p in prompts.RULES_MANAGED_PREFIXES):
+            f.unlink()
+
+    # 写入规则模块
+    for key, filename in prompts.RULES_FILES.items():
+        atomic_write(rules_dir / filename, prompts.RULES_MODULES[key])
+
+    print(f"✅ Deployed {len(prompts.RULES_FILES)} Rule Modules")
+
+
+def _cleanup_managed(directory, managed_names, prefix=None):
+    """清理受管理文件，保留用户自定义文件。
+
+    Args:
+        directory: 目标目录
+        managed_names: 受管理的文件名集合（含扩展名）
+        prefix: 如果提供，按前缀匹配清理；否则按 managed_names 精确匹配
+    """
+    if not directory.exists():
+        return
+    for f in directory.glob('*.md'):
+        if prefix and f.name.startswith(prefix):
+            f.unlink()
+        elif not prefix and f.name in managed_names:
+            f.unlink()
+
+
+def _deploy_expert(claude_root, agents_dir, commands_dir):
+    # 部署模块化规则
+    _deploy_rules(claude_root)
+
+    # 部署精简版 CLAUDE.md（@import 引用）
+    atomic_write(claude_root / "CLAUDE.md", prompts.CLAUDE_MD_TEMPLATE)
+    print("✅ Constitution Updated (Modular)")
+
+    # 清理旧的受管理 Agent 文件，保留用户自定义 Agent
+    managed_agent_files = {f"{name}.md" for name in prompts.AGENTS_EXPERT}
+    _cleanup_managed(agents_dir, managed_agent_files)
+
+    # 部署 Agents (满血版 + 高级字段)
+    OPTIONAL_FIELDS = ['permissionMode', 'disallowedTools', 'maxTurns', 'memory', 'skills']
+    for name, cfg in prompts.AGENTS_EXPERT.items():
+        agent_path = agents_dir / f"{name}.md"
+        content = [
+            "---",
+            f"name: {name}",
+            f"description: {cfg['desc']}",
+            f"tools: {cfg['tools']}",
+            f"model: {cfg.get('model', 'sonnet')}",
+        ]
+        for field in OPTIONAL_FIELDS:
+            if field in cfg:
+                content.append(f"{field}: {cfg[field]}")
+        content.extend([
+            "---",
+            "",
+            cfg['prompt'],
+            "",
+            "Please refer to ~/.claude/CLAUDE.md for routing."
+        ])
+        atomic_write(agent_path, "\n".join(content))
+    print(f"✅ Deployed {len(prompts.AGENTS_EXPERT)} Expert Agents")
+
+    # 清理旧的受管理 Command 文件，保留用户自定义命令
+    _cleanup_managed(commands_dir, set(), prefix="project-")
+
+    # 部署 Commands (满血版)
+    for filename, content in prompts.COMMANDS_CONTENT.items():
+        atomic_write(commands_dir / filename, content)
+    print(f"✅ Deployed {len(prompts.COMMANDS_CONTENT)} Command Playbooks")

pactkit/prompts/__init__.py

@@ -0,0 +1,45 @@
+from .agents import (
+    AGENTS_EXPERT,
+)
+from .commands import COMMANDS_CONTENT
+from .references import (
+    DEV_REF_BACKEND,
+    DEV_REF_FRONTEND,
+    REVIEW_REF_QUALITY,
+    REVIEW_REF_REMOVAL,
+    REVIEW_REF_SECURITY,
+    REVIEW_REF_SOLID,
+    TEST_REF_GO,
+    TEST_REF_JAVA,
+    TEST_REF_NODE,
+    TEST_REF_PYTHON,
+)
+from .rules import (
+    CLAUDE_MD_TEMPLATE,
+    CONSTITUTION_EXPERT,
+    RULES_FILES,
+    RULES_MANAGED_PREFIXES,
+    RULES_MODULES,
+)
+from .skills import (
+    BOARD_SOURCE,
+    SCAFFOLD_SOURCE,
+    SKILL_BOARD_MD,
+    SKILL_SCAFFOLD_MD,
+    SKILL_VISUALIZE_MD,
+    TOOLS_CONTENT,
+    TOOLS_SOURCE,
+    VISUALIZE_SOURCE,
+)
+from .workflows import (
+    DESIGN_PROMPT,
+    DRAW_PROMPT_TEMPLATE,
+    DRAW_REF_ANTI_BUGS,
+    DRAW_REF_LAYOUTS,
+    DRAW_REF_STYLES,
+    HOTFIX_PROMPT,
+    LANG_PROFILES,
+    REVIEW_PROMPT,
+    SPRINT_PROMPT,
+    TRACE_PROMPT,
+)