git-repokit 0.9.10__py3-none-any.whl

repokit/templates/layers/archetypes/js-ts/node-package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "__RK_PROJECT__",
+  "version": "0.1.0",
+  "description": "__RK_DESCRIPTION__",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "typecheck": "tsc --noEmit -p .",
+    "test": "tsc -p . && node --test",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

repokit/templates/layers/archetypes/js-ts/node-package/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * __RK_DESCRIPTION__
+ *
+ * The package's public surface. Everything exported here is what
+ * `import ... from "__RK_PROJECT__"` gives a consumer.
+ */
+
+export const name = "__RK_PROJECT__";
+
+/** A first function to replace with the package's work. */
+export function greet(who = "world"): string {
+  return `Hello, ${who}, from ${name}.`;
+}

repokit/templates/layers/archetypes/js-ts/node-package/tests/index.test.ts

@@ -0,0 +1,11 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { greet, name } from "../src/index.js";
+
+test("the package names itself", () => {
+  assert.equal(name, "__RK_PROJECT__");
+});
+
+test("greet greets", () => {
+  assert.equal(greet("tests"), `Hello, tests, from ${name}.`);
+});

repokit/templates/layers/archetypes/js-ts/script/.vscode/launch.json

@@ -0,0 +1,34 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "__RK_PROJECT__.js --version",
+      "type": "node",
+      "request": "launch",
+      "program": "${workspaceFolder}/__RK_PROJECT__.js",
+      "args": ["--version"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "skipFiles": ["<node_internals>/**"]
+    },
+    {
+      "name": "node: current file",
+      "type": "node",
+      "request": "launch",
+      "program": "${file}",
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "skipFiles": ["<node_internals>/**"]
+    },
+    {
+      "name": "npm test",
+      "type": "node",
+      "request": "launch",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": ["test"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "skipFiles": ["<node_internals>/**"]
+    }
+  ]
+}

repokit/templates/layers/archetypes/js-ts/script/__RK_PROJECT__.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// __RK_DESCRIPTION__
+//
+// A plain script: one file, run with node, no build step and no dependencies.
+// The version lives in the VERSION file beside this module (git-repokit-common's
+// version tool keeps it, package.json, the CHANGELOG and the tags in step).
+
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+export function readVersion() {
+  try {
+    return readFileSync(join(HERE, "VERSION"), "utf8").trim() || "0.0.0+unknown";
+  } catch {
+    return "0.0.0+unknown";
+  }
+}
+
+export function main(argv = process.argv.slice(2)) {
+  if (argv.includes("--version") || argv.includes("-V")) {
+    console.log(readVersion());
+    return 0;
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log("usage: __RK_PROJECT__ [--version] [--help]\n\n__RK_DESCRIPTION__");
+    return 0;
+  }
+  console.log("Hello from __RK_PROJECT__. Replace this with the script's work.");
+  return 0;
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  process.exit(main());
+}

repokit/templates/layers/archetypes/js-ts/script/tests/version.test.js

@@ -0,0 +1,26 @@
+// The script answers --version with the VERSION file's content, and --help exits 0.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const SCRIPT = join(ROOT, "__RK_PROJECT__.js");
+
+function run(...args) {
+  return spawnSync(process.execPath, [SCRIPT, ...args], { cwd: ROOT, encoding: "utf8" });
+}
+
+test("--version matches the VERSION file", () => {
+  const r = run("--version");
+  assert.equal(r.status, 0, r.stderr);
+  assert.equal(r.stdout.trim(), readFileSync(join(ROOT, "VERSION"), "utf8").trim());
+});
+
+test("--help exits cleanly and names the script", () => {
+  const r = run("--help");
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /__RK_PROJECT__/);
+});

repokit/templates/layers/archetypes/js-ts/ts/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "__RK_PROJECT__",
+  "version": "0.1.0",
+  "description": "__RK_DESCRIPTION__",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p .",
+    "typecheck": "tsc --noEmit -p .",
+    "test": "tsc -p . && node --test"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  }
+}

repokit/templates/layers/archetypes/js-ts/ts/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "sourceMap": true,
+    "rootDir": ".",
+    "outDir": "dist"
+  },
+  "include": ["src", "tests"]
+}

repokit/templates/layers/archetypes/python/claude-plugin/.github/workflows/ci-python.yml

@@ -0,0 +1,44 @@
+name: CI (Claude Code plugin, Python hooks)
+
+# The plugin has no package to install: every hook script must compile, the
+# node launcher must parse, and the plugin's tests run with pytest.
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ['3.10', '3.12']
+
+    steps:
+    - uses: actions/checkout@v7
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v7
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Set up Node
+      uses: actions/setup-node@v7
+      with:
+        node-version: '22'
+
+    - name: Compile the hooks and check the launcher
+      shell: bash
+      run: |
+        python -m py_compile plugin/hooks/scripts/*.py
+        node --check plugin/hooks/scripts/run-hook.mjs
+
+    - name: Run the plugin's tests
+      shell: bash
+      run: |
+        python -m pip install --upgrade pip pytest
+        python -m pytest plugin/tests -v

repokit/templates/layers/archetypes/python/claude-plugin/.repokit-common.toml

@@ -0,0 +1,21 @@
+# git-repokit-common settings for __RK_PROJECT__, a Claude Code plugin with Python hooks.
+#
+# The plugin lives in plugin/ with its own README for the marketplace; this
+# root holds the repository's tooling. The version lives in VERSION; the
+# vendored tool at scripts/repokit-common/ keeps the plugin manifest in step.
+# "human" tags (v0.1.0) match the version Claude Code reads from
+# plugin/.claude-plugin/plugin.json. A push runs the plugin's own tests.
+
+[tool.repokit-common]
+version-source = "VERSION"
+changelog = "CHANGELOG.md"
+repo-url = "https://github.com/__RK_ORG__/__RK_PROJECT__"
+tag-prefix = "v"
+tag-format = "human"
+private-patterns = ["private/", "local/", ".env"]
+test-command = "python -m pytest plugin/tests -q"
+
+[[tool.repokit-common.extra-targets]]
+path = "plugin/.claude-plugin/plugin.json"
+type = "json"
+field = "version"

repokit/templates/layers/archetypes/python/claude-plugin/.vscode/launch.json

@@ -0,0 +1,33 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Hook: session_start.py (type the event JSON, then Ctrl+Z Enter / Ctrl+D)",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${workspaceFolder}/plugin/hooks/scripts/session_start.py",
+      "cwd": "${workspaceFolder}",
+      "env": { "__RK_MACRO___DEBUG": "1" },
+      "console": "integratedTerminal",
+      "justMyCode": false
+    },
+    {
+      "name": "pytest: plugin tests",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "pytest",
+      "args": ["plugin/tests", "-q"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "justMyCode": false
+    },
+    {
+      "name": "Python: current file",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${file}",
+      "console": "integratedTerminal",
+      "justMyCode": false
+    }
+  ]
+}

repokit/templates/layers/archetypes/python/claude-plugin/VERSION

@@ -0,0 +1 @@
+0.1.0

repokit/templates/layers/archetypes/python/claude-plugin/plugin/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/run-hook.mjs\" session_start.py",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

repokit/templates/layers/archetypes/python/claude-plugin/plugin/hooks/scripts/run-hook.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Launch one of this plugin's Python hooks: node run-hook.mjs <script.py>
+//
+// Claude Code always has node (it is a node app), but `python3 || python` in
+// hooks.json depends on the shell the hook runs under, which differs by
+// platform. This launcher finds a Python 3 the platform's way round, runs the
+// named script beside it with the event passed through on stdin, and returns
+// its exit code. A missing Python or script is reported on stderr and exits 0,
+// so a broken hook never blocks the session. Modelled on
+// claude-session-logger's run-hook.mjs; the script name is an argument here,
+// so one launcher serves every hook.
+
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const NAME = "__RK_PROJECT__";
+const script = join(HERE, process.argv[2] || "session_start.py");
+
+function findPython() {
+  const candidates = process.platform === "win32" ? ["python", "python3", "py"] : ["python3", "python"];
+  for (const cmd of candidates) {
+    const r = spawnSync(cmd, ["--version"], { stdio: "pipe", timeout: 5000 });
+    const out = `${r.stdout || ""}${r.stderr || ""}`;
+    if (r.status === 0 && out.includes("Python 3")) return cmd;
+  }
+  return null;
+}
+
+const python = findPython();
+if (!python) {
+  process.stderr.write(`[${NAME}] Python 3 not found; install it and put python3 (or python) on PATH.\n`);
+  process.exit(0);
+}
+if (!existsSync(script)) {
+  process.stderr.write(`[${NAME}] hook script not found: ${script}\n`);
+  process.exit(0);
+}
+const r = spawnSync(python, [script], { stdio: "inherit", timeout: 60000 });
+process.exit(r.status || 0);

repokit/templates/layers/archetypes/python/claude-plugin/plugin/hooks/scripts/session_start.py

@@ -0,0 +1,31 @@
+"""SessionStart hook for __RK_PROJECT__.
+
+Claude Code runs this (through run-hook.mjs) when a session starts and passes
+the event as JSON on stdin. Anything printed to stdout as JSON with
+"additionalContext" reaches the session; an empty object is a no-op. Replace
+the body with the plugin's work; keep it quick (the hooks.json timeout is 10
+seconds).
+"""
+import json
+import os
+import sys
+
+
+def main() -> int:
+    try:
+        raw = sys.stdin.read()
+        event = json.loads(raw) if raw.strip() else {}
+    except (ValueError, OSError):
+        event = {}
+    output = {}
+    if os.environ.get("__RK_MACRO___DEBUG"):
+        output["additionalContext"] = (
+            f"__RK_PROJECT__ saw a {event.get('hook_event_name', 'SessionStart')} event "
+            f"(source: {event.get('source', 'unknown')})."
+        )
+    sys.stdout.write(json.dumps(output))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

repokit/templates/layers/archetypes/python/claude-plugin/plugin/tests/test_manifest.py

@@ -0,0 +1,42 @@
+"""The plugin's manifests parse, agree with VERSION, and the hook answers --
+directly and through the node launcher Claude Code runs."""
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+PLUGIN = Path(__file__).resolve().parents[1]
+ROOT = PLUGIN.parent
+SCRIPTS = PLUGIN / "hooks" / "scripts"
+EVENT = json.dumps({"hook_event_name": "SessionStart", "source": "startup"})
+
+
+def test_plugin_json_names_the_plugin_and_carries_version():
+    manifest = json.loads((PLUGIN / ".claude-plugin" / "plugin.json").read_text(encoding="utf-8"))
+    assert manifest["name"] == "__RK_PROJECT__"
+    assert manifest["version"] == (ROOT / "VERSION").read_text(encoding="utf-8").strip()
+
+
+def test_marketplace_lists_this_plugin_from_plugin_folder():
+    market = json.loads((ROOT / ".claude-plugin" / "marketplace.json").read_text(encoding="utf-8"))
+    assert any(p["source"] == "./plugin" and p["name"] == "__RK_PROJECT__" for p in market["plugins"])
+
+
+def test_the_session_start_hook_returns_json():
+    hooks = json.loads((PLUGIN / "hooks" / "hooks.json").read_text(encoding="utf-8"))
+    assert "SessionStart" in hooks["hooks"]
+    r = subprocess.run([sys.executable, str(SCRIPTS / "session_start.py")], input=EVENT,
+                       capture_output=True, text=True, timeout=30)
+    assert r.returncode == 0, r.stderr
+    json.loads(r.stdout)
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node is not on PATH")
+def test_the_node_launcher_runs_the_python_hook():
+    r = subprocess.run(["node", str(SCRIPTS / "run-hook.mjs"), "session_start.py"], input=EVENT,
+                       capture_output=True, text=True, timeout=60)
+    assert r.returncode == 0, r.stderr
+    json.loads(r.stdout)

repokit/templates/layers/archetypes/python/pypi/.github/workflows/release.yml

@@ -0,0 +1,63 @@
+name: Publish to PyPI
+
+# Triggered when a GitHub Release is PUBLISHED -- not on tag push. This makes
+# "publish a release" the single deliberate ship action: force-moving or
+# re-pushing a tag (e.g. amending a released commit) never re-fires PyPI, so
+# we don't get spurious "400 File already exists" failures. The release event
+# checks out the release's tag, so the right version is built.
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  build:
+    # Skip on the template repo itself (no pyproject.toml until instantiated)
+    if: github.repository != 'DazzleTools/git-repokit-template'
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v7
+
+    - name: Set up Python
+      uses: actions/setup-python@v7
+      with:
+        python-version: '3.11'
+
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+
+    - name: Build package
+      run: python -m build
+
+    - name: Check package
+      run: |
+        pip install twine
+        twine check dist/*
+
+    - uses: actions/upload-artifact@v7
+      with:
+        name: dist
+        path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+
+    permissions:
+      id-token: write
+
+    steps:
+    - uses: actions/download-artifact@v8
+      with:
+        name: dist
+        path: dist/
+
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

repokit/templates/layers/archetypes/python/pypi/.vscode/launch.json

@@ -0,0 +1,43 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "__RK_PROJECT__ --version",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "__RK_SNAKE__",
+      "args": ["--version"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "justMyCode": false
+    },
+    {
+      "name": "Python: current file",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${file}",
+      "console": "integratedTerminal",
+      "justMyCode": false
+    },
+    {
+      "name": "pytest: tests",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "pytest",
+      "args": ["tests", "-q"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "justMyCode": false
+    },
+    {
+      "name": "pytest: current file",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "pytest",
+      "args": ["${file}", "-q"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "justMyCode": false
+    }
+  ]
+}

repokit/templates/layers/archetypes/python/pypi/__RK_SNAKE__/__init__.py

@@ -0,0 +1,5 @@
+"""__RK_PROJECT__ - __RK_DESCRIPTION__"""
+
+from ._version import __version__, __app_name__, PIP_VERSION
+
+__all__ = ["__version__", "__app_name__", "PIP_VERSION"]

repokit/templates/layers/archetypes/python/pypi/__RK_SNAKE__/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as: python -m __RK_SNAKE__"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

repokit/templates/layers/archetypes/python/pypi/__RK_SNAKE__/_version.py

@@ -0,0 +1,96 @@
+"""
+Version information for __RK_PROJECT__.
+
+This file is the canonical source for version numbers.
+The __version__ string is automatically updated by git hooks
+with build metadata (branch, build number, date, commit hash).
+
+Format: MAJOR.MINOR.PATCH[-PHASE]_BRANCH_BUILD-YYYYMMDD-COMMITHASH
+Example: 0.1.0_main_1-20260101-a1b2c3d4
+
+To sync versions: python scripts/repokit-common/sync-versions.py
+To bump version: python scripts/repokit-common/sync-versions.py --bump patch
+
+Version levels:
+  PROJECT_PHASE: Global project maturity (prealpha -> alpha -> beta -> stable).
+                 Changes rarely, when the overall project hits a threshold.
+  PHASE:         Per-MINOR feature set maturity (alpha -> beta -> "" for stable).
+                 Drops when a MINOR's feature set is complete.
+"""
+
+# Version components - edit these for version bumps
+MAJOR = 0
+MINOR = 1
+PATCH = 0
+PHASE = ""  # Per-MINOR feature set: "" (stable), "alpha", "beta", "rc1", etc.
+PRE_RELEASE_NUM = 1  # PEP 440 pre-release number (e.g., a1, b2)
+
+# Project-level phase (independent of version phase)
+PROJECT_PHASE = ""  # "prealpha", "alpha", "beta", "stable", or ""
+
+# Auto-updated by git hooks - do not edit manually
+__version__ = "0.1.0"
+__app_name__ = "__RK_PROJECT__"
+
+
+def get_version():
+    """Return the full version string including branch and build info."""
+    return __version__
+
+
+def get_base_version():
+    """Return the semantic version string (MAJOR.MINOR.PATCH[-PHASE])."""
+    if "_" in __version__:
+        return __version__.split("_")[0]
+    base = f"{MAJOR}.{MINOR}.{PATCH}"
+    if PHASE:
+        base = f"{base}-{PHASE}"
+    return base
+
+
+def get_display_version():
+    """Return a human-friendly version string with project phase.
+
+    Example: 'PREALPHA 0.1.0-alpha' or 'BETA 0.5.1' or '1.0.0'
+    """
+    base = get_base_version()
+    if PROJECT_PHASE and PROJECT_PHASE != "stable":
+        return f"{PROJECT_PHASE.upper()} {base}"
+    return base
+
+
+def get_pip_version():
+    """
+    Return PEP 440 compliant version for pip/setuptools.
+
+    Converts our version format to PEP 440:
+    - Main branch: 0.1.0_main_3-20260404-hash -> 0.1.0
+    - Dev branch: 0.1.0_dev_3-20260404-hash -> 0.1.0.dev3
+    - Alpha: 0.1.0-alpha_main_3 -> 0.1.0a1
+    """
+    base = f"{MAJOR}.{MINOR}.{PATCH}"
+
+    # Map phase to PEP 440 pre-release segment
+    phase_map = {"alpha": f"a{PRE_RELEASE_NUM}", "beta": f"b{PRE_RELEASE_NUM}"}
+    if PHASE:
+        base += phase_map.get(PHASE, PHASE)
+
+    if "_" not in __version__:
+        return base
+
+    parts = __version__.split("_")
+    branch = parts[1] if len(parts) > 1 else "unknown"
+
+    if branch == "main":
+        return base
+    else:
+        build_info = "_".join(parts[2:]) if len(parts) > 2 else ""
+        build_num = build_info.split("-")[0] if "-" in build_info else "0"
+        return f"{base}.dev{build_num}"
+
+
+# For convenience in imports
+VERSION = get_version()
+BASE_VERSION = get_base_version()
+PIP_VERSION = get_pip_version()
+DISPLAY_VERSION = get_display_version()

repokit/templates/layers/archetypes/python/pypi/__RK_SNAKE__/cli.py

@@ -0,0 +1,18 @@
+"""Command-line entry point for __RK_PROJECT__ (the `__RK_PROJECT__` command)."""
+
+import argparse
+
+from ._version import __app_name__, get_display_version
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog=__app_name__, description="__RK_DESCRIPTION__")
+    parser.add_argument("--version", action="version", version=f"{__app_name__} {get_display_version()}")
+    return parser
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    del args  # nothing to do yet: replace this with the tool's work
+    print(f"{__app_name__} {get_display_version()}")
+    return 0