@normful/picadillo 1.0.2

package/cliff.toml

@@ -0,0 +1,94 @@
+# git-cliff ~ configuration file
+# https://git-cliff.org/docs/configuration
+
+
+[changelog]
+# A Tera template to be rendered for each release in the changelog.
+# See https://keats.github.io/tera/docs/#introduction
+body = """
+{% if version %}\
+    ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
+{% else %}\
+    ## [unreleased]
+{% endif %}\
+{% for group, commits in commits | group_by(attribute="group") %}
+    ### {{ group | striptags | trim | upper_first }}
+    {% for commit in commits %}
+        - {% if commit.scope %}*({{ commit.scope }})* {% endif %}\
+            {% if commit.breaking %}[**breaking**] {% endif %}\
+            {{ commit.message | upper_first }}\
+    {% endfor %}
+{% endfor %}
+"""
+# Remove leading and trailing whitespaces from the changelog's body.
+trim = true
+# Render body even when there are no releases to process.
+render_always = true
+# An array of regex based postprocessors to modify the changelog.
+postprocessors = [
+    # Replace the placeholder <REPO> with a URL.
+    #{ pattern = '<REPO>', replace = "https://github.com/orhun/git-cliff" },
+]
+# render body even when there are no releases to process
+# render_always = true
+# output file path
+# output = "test.md"
+
+[git]
+# Parse commits according to the conventional commits specification.
+# See https://www.conventionalcommits.org
+conventional_commits = true
+# Exclude commits that do not match the conventional commits specification.
+filter_unconventional = true
+# Require all commits to be conventional.
+# Takes precedence over filter_unconventional.
+require_conventional = false
+# Split commits on newlines, treating each line as an individual commit.
+split_commits = false
+# An array of regex based parsers to modify commit messages prior to further processing.
+commit_preprocessors = [
+    # Replace issue numbers with link templates to be updated in `changelog.postprocessors`.
+    #{ pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](<REPO>/issues/${2}))"},
+    # Check spelling of the commit message using https://github.com/crate-ci/typos.
+    # If the spelling is incorrect, it will be fixed automatically.
+    #{ pattern = '.*', replace_command = 'typos --write-changes -' },
+]
+# Prevent commits that are breaking from being excluded by commit parsers.
+protect_breaking_commits = false
+# An array of regex based parsers for extracting data from the commit message.
+# Assigns commits to groups.
+# Optionally sets the commit's scope and can decide to exclude commits from further processing.
+commit_parsers = [
+    { message = "^feat", group = "<!-- 0 -->🚀 Features" },
+    { message = "^fix", group = "<!-- 1 -->🐛 Bug Fixes" },
+    { message = "^doc", group = "<!-- 3 -->📚 Documentation" },
+    { message = "^perf", group = "<!-- 4 -->⚡ Performance" },
+    { message = "^refactor", group = "<!-- 2 -->🚜 Refactor" },
+    { message = "^style", group = "<!-- 5 -->🎨 Styling" },
+    { message = "^test", group = "<!-- 6 -->🧪 Testing" },
+    { message = "^chore\\(release\\): prepare for", skip = true },
+    { message = "^chore\\(deps.*\\)", skip = true },
+    { message = "^chore\\(pr\\)", skip = true },
+    { message = "^chore\\(pull\\)", skip = true },
+    { message = "^chore|^ci", group = "<!-- 7 -->⚙️ Miscellaneous Tasks" },
+    { body = ".*security", group = "<!-- 8 -->🛡️ Security" },
+    { message = "^revert", group = "<!-- 9 -->◀️ Revert" },
+    { message = ".*", group = "<!-- 10 -->💼 Other" },
+]
+# Exclude commits that are not matched by any commit parser.
+filter_commits = false
+# Fail on a commit that is not matched by any commit parser.
+fail_on_unmatched_commit = false
+# An array of link parsers for extracting external references, and turning them into URLs, using regex.
+link_parsers = []
+# Include only the tags that belong to the current branch.
+use_branch_tags = false
+# Order releases topologically instead of chronologically.
+topo_order = false
+# Order commits topologically instead of chronologically.
+topo_order_commits = true
+# Order of commits in each group/release within the changelog.
+# Allowed values: newest, oldest
+sort_commits = "oldest"
+# Process submodules commits
+recurse_submodules = false

package/generate-changelog.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -o errexit
+set -o pipefail
+
+LATEST_VERSION=$(node -p -e "require('./package.json').version")
+
+if [ "$1" = "stdout" ]; then
+    git-cliff --output - --unreleased --tag $LATEST_VERSION
+else
+    git-cliff --output './CHANGELOG.md' --tag $LATEST_VERSION
+fi

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@normful/picadillo",
+  "version": "1.0.2",
+  "private": false,
+  "description": "Norman's pi coding agent commands, skills, extensions",
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "coding-assistant",
+    "extensions",
+    "skills",
+    "ai",
+    "pi-package",
+    "pi-extension",
+    "pi-skill"
+  ],
+  "homepage": "https://github.com/normful/picadillo#readme",
+  "bugs": {
+    "url": "https://github.com/normful/picadillo/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/normful/picadillo.git"
+  },
+  "license": "MIT",
+  "author": "normful",
+  "type": "commonjs",
+  "main": "none",
+  "scripts": {
+    "test": "bun test",
+    "release": "release-it"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-tui": "*",
+    "typescript": "^5"
+  },
+  "pi": {
+    "prompts": [],
+    "extensions": [],
+    "skills": [
+      "./run-in-tmux/SKILL.md"
+    ]
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "release-it": "^19.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/skills/run-in-tmux/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: run-in-tmux
+description: Use when the user wants to run commands in a new tmux session with split panes. Triggers on requests like "run X in tmux", "start a dev environment in tmux", or "open multiple terminals in tmux".
+---
+
+# run-in-tmux
+
+Creates a tmux session with one or more commands running in separate split panes. Automatically detects the git repository root and generates a unique session name.
+
+## When to use
+
+- User wants to run development commands (e.g., `npm run dev`, `cargo watch`)
+- User needs multiple terminal panes running different commands
+- User wants to start a background process that persists after terminal closes
+
+## How to run
+
+The script is located at `scripts/run-in-tmux`. Execute it using `uv run`:
+
+```bash
+uv run scripts/run-in-tmux -c "npm run dev"
+```
+
+## Usage
+
+```bash
+# Single command (JSON output)
+uv run scripts/run-in-tmux -c "npm run dev" --json
+
+# Multiple commands (each gets its own pane)
+uv run scripts/run-in-tmux -c "npm run dev" -c "npm test" --json
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `-c, --command` | Command to run (required, repeatable) |
+| `--json` | Output JSON to stdout |
+| `--plain` | Line-based plain text output |
+| `-q, --quiet` | Suppress non-essential output |
+| `-v, --verbose` | Show debug details |
+| `--no-color` | Disable colored output |
+| `--version` | Show version and exit |
+
+## Output
+
+### JSON format (`--json`)
+```bash
+uv run scripts/run-in-tmux -c "echo hello" -c "echo world" --json
+```
+```json
+{
+  "success": true,
+  "session_name": "picadillo-1f4f1afa",
+  "commands": ["echo hello", "echo world"],
+  "panes": 2,
+  "working_directory": "/Users/norman/code/picadillo",
+  "attach_command": "tmux attach -t picadillo-1f4f1afa",
+  "peek_commands": [
+    "tmux capture-pane -t picadillo-1f4f1afa.0 -p",
+    "tmux capture-pane -t picadillo-1f4f1afa.1 -p"
+  ],
+  "kill_command": "tmux kill-session -t picadillo-1f4f1afa"
+}
+```
+
+## Session naming
+
+Session names follow the pattern `<repo-slug>-<hash>`:
+- `repo-slug`: First 8 characters of the git repository basename
+- `hash`: 8-character MD5 hash of the repo path + commands
+
+This ensures unique sessions for different commands in the same repo.
+
+## Requirements
+
+- Python 3.10+
+- tmux installed and running
+- Must be in a git repository
+- Dependencies: `typer`, `rich` (auto-installed via uv)

package/skills/run-in-tmux/scripts/run-in-tmux

@@ -0,0 +1,258 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["typer", "rich"]
+# ///
+
+"""
+run-in-tmux: Create a new tmux session for a project and run a command inside it.
+"""
+
+__version__ = "0.3.0"
+
+import hashlib
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+app = typer.Typer(add_completion=False)
+console = Console()
+
+
+def get_version() -> str:
+    return __version__
+
+
+def get_git_root() -> Path | None:
+    """Get the root directory of the current Git repository."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return Path(result.stdout.strip())
+    except subprocess.CalledProcessError:
+        return None
+
+
+def get_repo_name(path: Path) -> str:
+    """Get short slug from repo basename (first 16 chars, lowercase)."""
+    return path.name[:16].lower()
+
+
+def generate_session_name(repo_path: Path, commands: list[str]) -> str:
+    """Generate unique session name: <slug>-<hash> where hash = MD5(repo_path + commands)."""
+    # Combine repo absolute path with all commands concatenated
+    combined = str(repo_path.absolute()) + "".join(commands)
+    # MD5 hash
+    md5_hash = hashlib.md5(combined.encode()).hexdigest()
+    # Truncate to 8 chars
+    short_hash = md5_hash[:8]
+    # Get repo slug (first 8 chars of basename)
+    slug = get_repo_name(repo_path)
+    return f"{slug}-{short_hash}"
+
+
+def session_exists(session_name: str) -> bool:
+    """Check if a tmux session with the given name already exists."""
+    result = subprocess.run(
+        ["tmux", "has-session", "-t", session_name],
+        capture_output=True,
+    )
+    return result.returncode == 0
+
+
+def create_tmux_session(
+    session_name: str, working_dir: Path, commands: list[str]
+) -> bool:
+    """Create a new tmux session with each command in its own split pane."""
+    try:
+        # Create session with first command in pane 0
+        # -s: session name
+        # -c: working directory
+        subprocess.run(
+            ["tmux", "new-session", "-d", "-s", session_name, "-c", str(working_dir)],
+            check=True,
+        )
+        # Send first command to pane 0
+        subprocess.run(
+            ["tmux", "send-keys", "-t", f"{session_name}.0", commands[0], "C-m"],
+            check=True,
+        )
+
+        # For each subsequent command, create a new pane and run the command
+        for i, cmd in enumerate(commands[1:], start=1):
+            # Split the window horizontally
+            subprocess.run(
+                ["tmux", "split-window", "-h", "-t", session_name],
+                check=True,
+            )
+            # Select the new pane and send the command
+            subprocess.run(
+                ["tmux", "send-keys", "-t", f"{session_name}.{i}", cmd, "C-m"],
+                check=True,
+            )
+
+        # Arrange panes in a tiled layout
+        subprocess.run(
+            ["tmux", "select-layout", "-t", session_name, "tiled"],
+            check=True,
+        )
+
+        return True
+    except subprocess.CalledProcessError as e:
+        return False
+
+
+def output_human(session_name: str, commands: list[str], working_dir: Path) -> None:
+    """Output human-readable confirmation."""
+    console.print(f"[green]✓[/green] Session created: [bold]{session_name}[/bold]")
+    console.print(f"  Commands ({len(commands)}):")
+    for i, cmd in enumerate(commands, 1):
+        console.print(f"    {i}. {cmd}")
+    console.print(f"  Working directory: {working_dir}")
+    console.print()
+    console.print("[bold]Attach to session:[/bold]")
+    console.print(f"  tmux attach -t {session_name}")
+    console.print()
+    console.print("[bold]Peek pane output:[/bold]")
+    for i in range(len(commands)):
+        console.print(f"  tmux capture-pane -t {session_name}.{i} -p")
+    console.print()
+    console.print("[bold]Kill session:[/bold]")
+    console.print(f"  tmux kill-session -t {session_name}")
+
+
+def output_json(session_name: str, commands: list[str], working_dir: Path) -> None:
+    """Output JSON for scripting."""
+    import json
+
+    output = {
+        "success": True,
+        "session_name": session_name,
+        "commands": commands,
+        "panes": len(commands),
+        "working_directory": str(working_dir),
+        "attach_command": f"tmux attach -t {session_name}",
+        "peek_commands": [
+            f"tmux capture-pane -t {session_name}.{i} -p" for i in range(len(commands))
+        ],
+        "kill_command": f"tmux kill-session -t {session_name}",
+    }
+    print(json.dumps(output))
+
+
+def output_plain(session_name: str, commands: list[str], working_dir: Path) -> None:
+    """Output line-based plain text."""
+    print(session_name)
+    for cmd in commands:
+        print(cmd)
+    print(str(working_dir))
+    print(f"tmux attach -t {session_name}")
+    for i in range(len(commands)):
+        print(f"tmux capture-pane -t {session_name}.{i} -p")
+    print(f"tmux kill-session -t {session_name}")
+
+
+def error_exit(message: str, json_output: bool = False) -> None:
+    """Print error to both stdout and stderr, exit with code 1."""
+    if json_output:
+        import json
+
+        print(json.dumps({"success": False, "error": message}), file=sys.stderr)
+    else:
+        # Use styled output for stderr - use Console with stderr, force color
+        err_console = Console(
+            stderr=True, force_terminal=True, no_color=console.no_color
+        )
+        err_console.print(f"[red]Error:[/red] {message}")
+    raise typer.Exit(code=1)
+
+
+@app.command()
+def main(
+    command: list[str] | None = typer.Option(
+        None,
+        "--command",
+        "-c",
+        help="Command to run inside tmux session. Repeat for multiple sequential commands.",
+    ),
+    json: bool = typer.Option(False, "--json", help="Output JSON to stdout"),
+    plain: bool = typer.Option(False, "--plain", help="Line-based plain text output"),
+    quiet: bool = typer.Option(
+        False, "-q", "--quiet", help="Suppress non-essential output"
+    ),
+    verbose: bool = typer.Option(False, "-v", "--verbose", help="Show debug details"),
+    no_color: bool = typer.Option(False, "--no-color", help="Disable colored output"),
+    version: bool = typer.Option(False, "--version", help="Show version and exit"),
+):
+    """
+    Create a new tmux session for a project and run commands in separate panes.
+
+    Each command runs in its own split pane of the first window.
+
+    Examples:
+
+        run-in-tmux -c "npm run dev"
+        run-in-tmux -c "npm run dev" -c "npm test"
+        run-in-tmux -c "echo one" -c "echo two" -c "echo three"
+    """
+    # Handle version flag first
+    if version:
+        print(get_version())
+        raise typer.Exit(code=0)
+
+    # Handle no-color
+    if no_color:
+        console.no_color = True
+
+    # Validate required --command
+    if command is None or len(command) == 0:
+        error_exit('--command is required. Usage: run-in-tmux -c "npm test"', False)
+
+    # Check if in a git repo
+    git_root = get_git_root()
+    if git_root is None:
+        error_exit("not in a git repository. Run from a project root.", json)
+
+    if verbose:
+        console.print(f"[dim]Git root: {git_root}[/dim]")
+
+    # Generate session name
+    session_name = generate_session_name(git_root, command)
+
+    if verbose:
+        console.print(f"[dim]Session name: {session_name}[/dim]")
+
+    # Check if session already exists
+    if session_exists(session_name):
+        error_exit(
+            f"session {session_name} already exists.\nUse tmux attach -t {session_name} to reconnect.",
+            json,
+        )
+
+    # Create the tmux session
+    success = create_tmux_session(session_name, git_root, command)
+    if not success:
+        error_exit("failed to create tmux session.", json)
+
+    # Output based on flags
+    if json:
+        output_json(session_name, command, git_root)
+    elif plain:
+        output_plain(session_name, command, git_root)
+    else:
+        output_human(session_name, command, git_root)
+
+    raise typer.Exit(code=0)
+
+
+if __name__ == "__main__":
+    app()
+
+# vim: ft=python