git-repokit 0.9.10__py3-none-any.whl

repokit/templates/layers/archetypes/c-cpp/cmake-app/.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "__RK_PROJECT__ --version (Windows, Debug)",
+      "type": "cppvsdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/build/Debug/__RK_PROJECT__.exe",
+      "args": ["--version"],
+      "cwd": "${workspaceFolder}",
+      "stopAtEntry": false,
+      "environment": [],
+      "console": "integratedTerminal",
+      "preLaunchTask": "Build Debug"
+    },
+    {
+      "name": "__RK_PROJECT__ --version (gdb, single-config build)",
+      "type": "cppdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/build/__RK_PROJECT__",
+      "args": ["--version"],
+      "cwd": "${workspaceFolder}",
+      "stopAtEntry": false,
+      "environment": [],
+      "MIMode": "gdb",
+      "preLaunchTask": "Build Debug"
+    }
+  ]
+}

repokit/templates/layers/archetypes/c-cpp/cmake-app/.vscode/tasks.json

@@ -0,0 +1,26 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Configure",
+      "detail": "cmake --preset windows-release (once, and after CMakeLists.txt changes); the Visual Studio generator builds Debug and Release from one configure",
+      "type": "shell",
+      "command": "cmake --preset windows-release",
+      "problemMatcher": []
+    },
+    {
+      "label": "Build Debug",
+      "type": "shell",
+      "command": "cmake --build build --config Debug",
+      "group": { "kind": "build", "isDefault": true },
+      "problemMatcher": ["$msCompile", "$gcc"]
+    },
+    {
+      "label": "Test",
+      "type": "shell",
+      "command": "ctest --test-dir build -C Debug --output-on-failure",
+      "group": "test",
+      "problemMatcher": []
+    }
+  ]
+}

repokit/templates/layers/archetypes/c-cpp/cmake-app/CMakeLists.txt

@@ -0,0 +1,47 @@
+cmake_minimum_required(VERSION 3.20)
+
+# The version lives in one place: include/__RK_SNAKE__/version.h (edited by
+# repokit-common's sync-versions.py). CMake reads it here; it is never typed twice.
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/__RK_SNAKE__/version.h" _rk_ver
+     REGEX "^#define __RK_MACRO___VERSION_(MAJOR|MINOR|PATCH) ")
+foreach(_line IN LISTS _rk_ver)
+    string(REGEX MATCH "_(MAJOR|MINOR|PATCH) +([0-9]+)" _m "${_line}")
+    set(_rk_${CMAKE_MATCH_1} ${CMAKE_MATCH_2})
+endforeach()
+
+project(__RK_PROJECT__
+    VERSION ${_rk_MAJOR}.${_rk_MINOR}.${_rk_PATCH}
+    DESCRIPTION "__RK_DESCRIPTION__"
+    LANGUAGES CXX RC)
+message(STATUS "__RK_PROJECT__ version ${PROJECT_VERSION}")
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(MSVC)
+    add_compile_options(/utf-8 /W4)
+endif()
+
+# Build stamp, generated at build time so commits never dirty the tree:
+# <version>_<branch>_<build count>-<date>-<short hash>.
+add_custom_target(__RK_SNAKE___stamp ALL
+    COMMAND ${CMAKE_COMMAND}
+        -DSRC_DIR=${CMAKE_CURRENT_SOURCE_DIR}
+        -DOUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/generated/__RK_SNAKE___stamp.h
+        -DBASE_VERSION=${PROJECT_VERSION}
+        -DMACRO=__RK_MACRO__
+        -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/GenerateStamp.cmake
+    BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/generated/__RK_SNAKE___stamp.h
+    COMMENT "Version stamp")
+
+add_executable(__RK_PROJECT__ src/main.cpp)
+if(WIN32)
+    target_sources(__RK_PROJECT__ PRIVATE src/app.rc)
+endif()
+target_include_directories(__RK_PROJECT__ PRIVATE
+    include ${CMAKE_CURRENT_BINARY_DIR}/generated)
+add_dependencies(__RK_PROJECT__ __RK_SNAKE___stamp)
+
+enable_testing()
+add_executable(test_version tests/test_version.cpp)
+target_include_directories(test_version PRIVATE include)
+add_test(NAME version COMMAND test_version)

repokit/templates/layers/archetypes/c-cpp/cmake-app/CMakePresets.json

@@ -0,0 +1,23 @@
+{
+  "version": 6,
+  "configurePresets": [
+    {
+      "name": "windows-release",
+      "generator": "Visual Studio 17 2022",
+      "architecture": "x64",
+      "binaryDir": "${sourceDir}/build",
+      "toolchainFile": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
+    }
+  ],
+  "buildPresets": [
+    { "name": "windows-release", "configurePreset": "windows-release", "configuration": "Release" }
+  ],
+  "testPresets": [
+    {
+      "name": "windows-release",
+      "configurePreset": "windows-release",
+      "configuration": "Release",
+      "output": { "outputOnFailure": true }
+    }
+  ]
+}

repokit/templates/layers/archetypes/c-cpp/cmake-app/cmake/GenerateStamp.cmake

@@ -0,0 +1,45 @@
+# Writes OUT_FILE with <MACRO>_VERSION_FULL in the house format:
+#   <base>_<branch>_<build count>-<YYYYMMDD>-<short hash>
+# Outside a git checkout (a source archive) the git fields read "unknown".
+# The file is rewritten only when its content changes, so builds stay incremental.
+function(_rk_git out)
+    execute_process(COMMAND git ${ARGN} WORKING_DIRECTORY "${SRC_DIR}"
+        OUTPUT_VARIABLE _o ERROR_QUIET RESULT_VARIABLE _rc OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(_rc EQUAL 0 AND NOT _o STREQUAL "")
+        set(${out} "${_o}" PARENT_SCOPE)
+    else()
+        set(${out} "unknown" PARENT_SCOPE)
+    endif()
+endfunction()
+
+# Only this project's own repository counts. A source tree unpacked inside
+# another checkout (an archive under a home-directory repo, a vendored copy)
+# must not take that outer repository's branch, count and hash.
+_rk_git(_top rev-parse --show-toplevel)
+get_filename_component(_src_real "${SRC_DIR}" REALPATH)
+if(NOT _top STREQUAL "unknown")
+    get_filename_component(_top "${_top}" REALPATH)
+endif()
+string(TOLOWER "${_src_real}" _src_l)
+string(TOLOWER "${_top}" _top_l)
+if(_top_l STREQUAL _src_l)
+    _rk_git(_branch rev-parse --abbrev-ref HEAD)
+    _rk_git(_count rev-list --count HEAD)
+    _rk_git(_hash rev-parse --short HEAD)
+    _rk_git(_date log -1 --format=%cd --date=format:%Y%m%d)
+else()
+    foreach(_v _branch _count _hash _date)
+        set(${_v} "unknown")
+    endforeach()
+endif()
+
+set(_full "${BASE_VERSION}_${_branch}_${_count}-${_date}-${_hash}")
+set(_text "#pragma once\n#define ${MACRO}_VERSION_FULL \"${_full}\"\n")
+if(EXISTS "${OUT_FILE}")
+    file(READ "${OUT_FILE}" _old)
+else()
+    set(_old "")
+endif()
+if(NOT _old STREQUAL _text)
+    file(WRITE "${OUT_FILE}" "${_text}")
+endif()

repokit/templates/layers/archetypes/c-cpp/cmake-app/src/main.cpp

@@ -0,0 +1,27 @@
+// __RK_PROJECT__ -- __RK_DESCRIPTION__
+#include <cctype>
+#include <cstdio>
+#include <cstring>
+
+#include "__RK_SNAKE__/version.h"
+#include "__RK_SNAKE___stamp.h"
+
+// Like Python's get_display_version(): "ALPHA 0.1.0" while the project-wide
+// phase is set, "0.1.0" once it is empty or "stable".
+static void print_project_phase() {
+    const char* phase = __RK_MACRO___PROJECT_PHASE;
+    if (phase[0] == '\0' || std::strcmp(phase, "stable") == 0) return;
+    for (; *phase; ++phase) std::putchar(std::toupper(static_cast<unsigned char>(*phase)));
+    std::putchar(' ');
+}
+
+int main(int argc, char** argv) {
+    if (argc > 1 && std::strcmp(argv[1], "--version") == 0) {
+        std::printf("__RK_PROJECT__ ");
+        print_project_phase();
+        std::printf("%s (%s)\n", __RK_MACRO___VERSION_STRING, __RK_MACRO___VERSION_FULL);
+        return 0;
+    }
+    std::printf("__RK_PROJECT__: try --version\n");
+    return 0;
+}

repokit/templates/layers/archetypes/c-cpp/cmake-app/tests/test_version.cpp

@@ -0,0 +1,20 @@
+// The version string agrees with its components. A plain assert executable,
+// registered with CTest (the xormove pattern: no test framework needed).
+#include <cassert>
+#include <cstdio>
+#include <string>
+
+#include "__RK_SNAKE__/version.h"
+
+int main() {
+    std::string expected = std::to_string(__RK_MACRO___VERSION_MAJOR) + "." +
+                           std::to_string(__RK_MACRO___VERSION_MINOR) + "." +
+                           std::to_string(__RK_MACRO___VERSION_PATCH);
+    std::string phase = __RK_MACRO___VERSION_PHASE;
+    if (!phase.empty()) expected += "-" + phase;
+    if (expected != __RK_MACRO___VERSION_STRING) {
+        std::printf("version string %s != components %s\n", __RK_MACRO___VERSION_STRING, expected.c_str());
+        return 1;
+    }
+    return 0;
+}

repokit/templates/layers/archetypes/c-cpp/cmake-app/vcpkg.json

@@ -0,0 +1,5 @@
+{
+  "name": "__RK_PROJECT__",
+  "version-string": "0.1.0",
+  "dependencies": []
+}

repokit/templates/layers/archetypes/c-cpp/minimal/.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "__RK_PROJECT__ --version (Windows; build.bat first, from a Developer Command Prompt)",
+      "type": "cppvsdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/build/__RK_PROJECT__.exe",
+      "args": ["--version"],
+      "cwd": "${workspaceFolder}",
+      "stopAtEntry": false,
+      "environment": [],
+      "console": "integratedTerminal"
+    },
+    {
+      "name": "__RK_PROJECT__ --version (gdb; make first)",
+      "type": "cppdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/build/__RK_PROJECT__",
+      "args": ["--version"],
+      "cwd": "${workspaceFolder}",
+      "stopAtEntry": false,
+      "environment": [],
+      "MIMode": "gdb"
+    }
+  ]
+}

repokit/templates/layers/archetypes/c-cpp/minimal/Makefile

@@ -0,0 +1,10 @@
+CC ?= cc
+CFLAGS ?= -O2 -Wall -Iinclude
+
+build/__RK_PROJECT__: src/__RK_SNAKE__.c include/__RK_SNAKE__/version.h
+	mkdir -p build
+	$(CC) $(CFLAGS) -o $@ src/__RK_SNAKE__.c
+
+.PHONY: clean
+clean:
+	rm -rf build

repokit/templates/layers/archetypes/c-cpp/minimal/build.bat

@@ -0,0 +1,7 @@
+@echo off
+rem Build __RK_PROJECT__ with MSVC (run from a Developer Command Prompt).
+setlocal
+cd /d "%~dp0"
+if not exist build mkdir build
+rc /nologo /I include /fo build\app.res src\app.rc || exit /b 1
+cl /nologo /O2 /utf-8 /W4 /I include /Fo:build\ /Fe:build\__RK_PROJECT__.exe src\__RK_SNAKE__.c build\app.res || exit /b 1

repokit/templates/layers/archetypes/c-cpp/minimal/src/__RK_SNAKE__.c

@@ -0,0 +1,26 @@
+/* __RK_PROJECT__ -- __RK_DESCRIPTION__ */
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "__RK_SNAKE__/version.h"
+
+/* Like Python's get_display_version(): "ALPHA 0.1.0" while the project-wide
+ * phase is set, "0.1.0" once it is empty or "stable". */
+static void print_project_phase(void) {
+    const char *phase = __RK_MACRO___PROJECT_PHASE;
+    if (phase[0] == '\0' || strcmp(phase, "stable") == 0) return;
+    for (; *phase; ++phase) putchar(toupper((unsigned char)*phase));
+    putchar(' ');
+}
+
+int main(int argc, char **argv) {
+    if (argc > 1 && strcmp(argv[1], "--version") == 0) {
+        printf("__RK_PROJECT__ ");
+        print_project_phase();
+        printf("%s\n", __RK_MACRO___VERSION_STRING);
+        return 0;
+    }
+    printf("__RK_PROJECT__: try --version\n");
+    return 0;
+}

repokit/templates/layers/archetypes/c-cpp/msbuild/.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "__RK_PROJECT__ --version (Debug x64)",
+      "type": "cppvsdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/x64/Debug/__RK_PROJECT__.exe",
+      "args": ["--version"],
+      "cwd": "${workspaceFolder}",
+      "stopAtEntry": false,
+      "environment": [],
+      "console": "integratedTerminal",
+      "preLaunchTask": "Build Debug"
+    }
+  ]
+}

repokit/templates/layers/archetypes/c-cpp/msbuild/.vscode/tasks.json

@@ -0,0 +1,20 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Build Debug",
+      "detail": "run VS Code from a Developer Command Prompt (or with msbuild on PATH)",
+      "type": "shell",
+      "command": "msbuild __RK_PROJECT__.sln -p:Configuration=Debug -p:Platform=x64",
+      "group": { "kind": "build", "isDefault": true },
+      "problemMatcher": ["$msCompile"]
+    },
+    {
+      "label": "Build Release",
+      "type": "shell",
+      "command": "msbuild __RK_PROJECT__.sln -p:Configuration=Release -p:Platform=x64",
+      "group": "build",
+      "problemMatcher": ["$msCompile"]
+    }
+  ]
+}

repokit/templates/layers/archetypes/c-cpp/msbuild/__RK_PROJECT__.sln

@@ -0,0 +1,19 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "__RK_PROJECT__", "__RK_PROJECT__.vcxproj", "{__RK_GUID_PROJECT__}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{__RK_GUID_PROJECT__}.Release|x64.ActiveCfg = Release|x64
+		{__RK_GUID_PROJECT__}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {__RK_GUID_SOLUTION__}
+	EndGlobalSection
+EndGlobal

repokit/templates/layers/archetypes/c-cpp/msbuild/__RK_PROJECT__.vcxproj

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>17.0</VCProjectVersion>
+    <ProjectGuid>{__RK_GUID_PROJECT__}</ProjectGuid>
+    <RootNamespace>__RK_PASCAL__</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <AdditionalIncludeDirectories>$(ProjectDir)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>$(ProjectDir)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ResourceCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="src\main.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="include\__RK_SNAKE__\version.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="src\app.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

repokit/templates/layers/archetypes/c-cpp/msbuild/src/main.cpp

@@ -0,0 +1,26 @@
+// __RK_PROJECT__ -- __RK_DESCRIPTION__
+#include <cctype>
+#include <cstdio>
+#include <cstring>
+
+#include "__RK_SNAKE__/version.h"
+
+// Like Python's get_display_version(): "ALPHA 0.1.0" while the project-wide
+// phase is set, "0.1.0" once it is empty or "stable".
+static void print_project_phase() {
+    const char* phase = __RK_MACRO___PROJECT_PHASE;
+    if (phase[0] == '\0' || std::strcmp(phase, "stable") == 0) return;
+    for (; *phase; ++phase) std::putchar(std::toupper(static_cast<unsigned char>(*phase)));
+    std::putchar(' ');
+}
+
+int main(int argc, char** argv) {
+    if (argc > 1 && std::strcmp(argv[1], "--version") == 0) {
+        std::printf("__RK_PROJECT__ ");
+        print_project_phase();
+        std::printf("%s\n", __RK_MACRO___VERSION_STRING);
+        return 0;
+    }
+    std::printf("__RK_PROJECT__: try --version\n");
+    return 0;
+}

repokit/templates/layers/archetypes/js-ts/claude-plugin/.repokit-common.toml

@@ -0,0 +1,28 @@
+# git-repokit-common settings for __RK_PROJECT__, a Claude Code plugin.
+#
+# 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 package.json and the plugin
+# manifest in step. "human" tags (v0.1.0) match the version Claude Code reads
+# from plugin/.claude-plugin/plugin.json.
+
+[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"]
+# What a push runs: npm test, once the dependencies are installed (see the
+# js-ts language layer's settings for why the guard is there).
+test-command = "if [ -d node_modules ] || ! grep -q devDependencies package.json; then npm test; else echo dependencies not installed: run npm install and the push will run npm test; fi"
+
+[[tool.repokit-common.extra-targets]]
+path = "package.json"
+type = "json"
+field = "version"
+
+[[tool.repokit-common.extra-targets]]
+path = "plugin/.claude-plugin/plugin.json"
+type = "json"
+field = "version"

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

@@ -0,0 +1,34 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Hook: session-start.mjs (type the event JSON, then Ctrl+Z Enter / Ctrl+D)",
+      "type": "node",
+      "request": "launch",
+      "program": "${workspaceFolder}/plugin/hooks/scripts/session-start.mjs",
+      "cwd": "${workspaceFolder}",
+      "env": { "__RK_MACRO___DEBUG": "1" },
+      "console": "integratedTerminal",
+      "skipFiles": ["<node_internals>/**"]
+    },
+    {
+      "name": "npm test",
+      "type": "node",
+      "request": "launch",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": ["test"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "skipFiles": ["<node_internals>/**"]
+    },
+    {
+      "name": "node: current file",
+      "type": "node",
+      "request": "launch",
+      "program": "${file}",
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "skipFiles": ["<node_internals>/**"]
+    }
+  ]
+}

repokit/templates/layers/archetypes/js-ts/claude-plugin/plugin/hooks/hooks.json

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

repokit/templates/layers/archetypes/js-ts/claude-plugin/plugin/hooks/scripts/session-start.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// SessionStart hook for __RK_PROJECT__.
+//
+// Claude Code runs this 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 { readFileSync } from "node:fs";
+
+let event = {};
+try {
+  const raw = readFileSync(0, "utf8");
+  event = raw.trim() ? JSON.parse(raw) : {};
+} catch {
+  event = {};
+}
+
+const output = {};
+if (process.env.__RK_MACRO___DEBUG) {
+  output.additionalContext = `__RK_PROJECT__ saw a ${event.hook_event_name ?? "SessionStart"} event (source: ${event.source ?? "unknown"}).`;
+}
+process.stdout.write(JSON.stringify(output));

repokit/templates/layers/archetypes/js-ts/claude-plugin/plugin/tests/manifest.test.js

@@ -0,0 +1,30 @@
+// The plugin's manifests parse, agree with VERSION, and the hook script answers.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN = join(dirname(fileURLToPath(import.meta.url)), "..");
+const ROOT = join(PLUGIN, "..");
+
+test("plugin.json names the plugin and carries VERSION", () => {
+  const manifest = JSON.parse(readFileSync(join(PLUGIN, ".claude-plugin", "plugin.json"), "utf8"));
+  assert.equal(manifest.name, "__RK_PROJECT__");
+  assert.equal(manifest.version, readFileSync(join(ROOT, "VERSION"), "utf8").trim());
+});
+
+test("marketplace.json lists this plugin from ./plugin", () => {
+  const marketplace = JSON.parse(readFileSync(join(ROOT, ".claude-plugin", "marketplace.json"), "utf8"));
+  assert.ok(marketplace.plugins.some((p) => p.source === "./plugin" && p.name === "__RK_PROJECT__"));
+});
+
+test("hooks.json parses and the SessionStart script returns JSON", () => {
+  const hooks = JSON.parse(readFileSync(join(PLUGIN, "hooks", "hooks.json"), "utf8"));
+  assert.ok(hooks.hooks.SessionStart);
+  const r = spawnSync(process.execPath, [join(PLUGIN, "hooks", "scripts", "session-start.mjs")],
+    { input: JSON.stringify({ hook_event_name: "SessionStart", source: "startup" }), encoding: "utf8" });
+  assert.equal(r.status, 0, r.stderr);
+  assert.doesNotThrow(() => JSON.parse(r.stdout));
+});

repokit/templates/layers/archetypes/js-ts/node/.repokit-common.toml.rkappend

@@ -0,0 +1,6 @@
+
+# package.json carries the same version; the version tool keeps it in step.
+[[tool.repokit-common.extra-targets]]
+path = "package.json"
+type = "json"
+field = "version"

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

@@ -0,0 +1,13 @@
+{
+  "name": "__RK_PROJECT__",
+  "version": "0.1.0",
+  "description": "__RK_DESCRIPTION__",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}

repokit/templates/layers/archetypes/js-ts/node-package/.github/workflows/release.yml

@@ -0,0 +1,39 @@
+name: Publish to npm
+
+# Triggered when a GitHub Release is PUBLISHED -- not on tag push -- so that
+# "publish a release" is the single deliberate ship action. The release event
+# checks out the release's tag, so the right version is built. Needs an
+# NPM_TOKEN secret (an automation token) on the repository.
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v7
+
+    - name: Set up Node
+      uses: actions/setup-node@v7
+      with:
+        node-version: '22'
+        registry-url: 'https://registry.npmjs.org'
+
+    - name: Install
+      shell: bash
+      run: |
+        if [ -f package-lock.json ]; then npm ci; else npm install; fi
+
+    - name: Test
+      run: npm test
+
+    - name: Publish
+      run: npm publish --provenance --access public
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}