ossplate 0.1.0

package/README.md

@@ -0,0 +1,7 @@
+# JavaScript Wrapper For Ossplate
+
+This package is the JavaScript wrapper surface for Ossplate.
+
+It delegates to the canonical Rust binary instead of implementing its own CLI behavior.
+
+Use `OSSPLATE_BINARY` during local development to point the wrapper at a specific binary.

package/bin/darwin-x64/ossplate

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+printf '{"status":"packaged-stub"}\n'

package/bin/linux-x64/ossplate

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+printf '{"status":"packaged-stub"}\n'

package/bin/ossplate.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runOssplate } from "../dist/index.js";
+
+runOssplate(process.argv.slice(2));

package/bin/win32-x64/ossplate.exe

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+printf '{"status":"packaged-stub"}\n'

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export declare function resolveOssplateBinary(options?: {
+    baseDir?: string;
+    platform?: NodeJS.Platform;
+    arch?: string;
+}): string;
+export declare function runOssplate(args?: string[], options?: {
+    baseDir?: string;
+    platform?: NodeJS.Platform;
+    arch?: string;
+}): void;

package/dist/index.js

@@ -0,0 +1,56 @@
+import { accessSync, constants } from "node:fs";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { arch as runtimeArch, platform as runtimePlatform } from "node:os";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ENV_OVERRIDE = "OSSPLATE_BINARY";
+const TEMPLATE_ROOT_ENV = "OSSPLATE_TEMPLATE_ROOT";
+const TARGETS = {
+    darwin: { arm64: "darwin-arm64", x64: "darwin-x64" },
+    linux: { x64: "linux-x64" },
+    win32: { x64: "win32-x64" }
+};
+export function resolveOssplateBinary(options = {}) {
+    const envOverride = process.env[ENV_OVERRIDE];
+    if (envOverride) {
+        return envOverride;
+    }
+    const platform = options.platform ?? runtimePlatform();
+    const arch = options.arch ?? runtimeArch();
+    const target = TARGETS[platform]?.[arch];
+    if (!target) {
+        throw new Error(`Unsupported platform/arch: ${platform}/${arch}`);
+    }
+    const executable = platform === "win32" ? "ossplate.exe" : "ossplate";
+    const baseDir = options.baseDir ?? join(__dirname, "..");
+    const packagedPath = join(baseDir, "bin", target, executable);
+    assertExecutable(packagedPath);
+    return packagedPath;
+}
+export function runOssplate(args = [], options = {}) {
+    const binPath = resolveOssplateBinary(options);
+    const baseDir = options.baseDir ?? join(__dirname, "..");
+    const child = spawn(binPath, args, {
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            [TEMPLATE_ROOT_ENV]: process.env[TEMPLATE_ROOT_ENV] ?? join(baseDir, "scaffold")
+        }
+    });
+    child.on("exit", (code) => {
+        process.exit(code ?? 0);
+    });
+    child.on("error", (error) => {
+        console.error(`ossplate: ${error.message}`);
+        process.exit(1);
+    });
+}
+function assertExecutable(filePath) {
+    try {
+        accessSync(filePath, constants.X_OK);
+    }
+    catch {
+        throw new Error(`Bundled ossplate binary not found or not executable at ${filePath}`);
+    }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "author": "Stef <stefdevscore@github.com>",
+  "bin": {
+    "ossplate": "bin/ossplate.js"
+  },
+  "description": "A practical baseline for shipping one project across Cargo, npm, and PyPI without starting from scratch every time.",
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "scaffold",
+    "scaffold/.gitignore"
+  ],
+  "keywords": [
+    "oss",
+    "ossplate",
+    "cli"
+  ],
+  "license": "Unlicense",
+  "main": "./dist/index.js",
+  "name": "ossplate",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "wrapper-js",
+    "type": "git",
+    "url": "https://github.com/stefdevscore/ossplate"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "pack:check": "npm pack --dry-run",
+    "prepack": "node ../scripts/stage-distribution-assets.mjs",
+    "stage:dist": "node ../scripts/stage-distribution-assets.mjs",
+    "test": "npm run build && node --test test/cli.test.js"
+  },
+  "type": "module",
+  "version": "0.1.0"
+}

package/scaffold/.github/workflows/ci.yml

@@ -0,0 +1,76 @@
+# ossplate:workflow-name:start
+name: Ossplate CI
+# ossplate:workflow-name:end
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  template-readiness:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: cargo run --quiet --manifest-path core-rs/Cargo.toml -- validate
+      - run: cargo run --quiet --manifest-path core-rs/Cargo.toml -- sync --check
+      - run: node --test ./scripts/validate-template-readiness.test.mjs
+
+  rust:
+    needs: template-readiness
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo fmt --check
+        working-directory: ./core-rs
+      - run: cargo clippy -- -D warnings
+        working-directory: ./core-rs
+      - run: cargo test
+        working-directory: ./core-rs
+
+  js:
+    needs: template-readiness
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: npm
+          cache-dependency-path: ./wrapper-js/package-lock.json
+      - run: npm ci
+        working-directory: ./wrapper-js
+      - run: npm run build
+        working-directory: ./wrapper-js
+      - run: npm test
+        working-directory: ./wrapper-js
+      - run: npm pack --dry-run
+        working-directory: ./wrapper-js
+
+  python:
+    needs: template-readiness
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Test and build
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .
+          pip install build
+          python -m unittest discover -s tests -p 'test_*.py'
+          python -m build --wheel
+        working-directory: ./wrapper-py

package/scaffold/.github/workflows/publish-npm.yml

@@ -0,0 +1,45 @@
+# ossplate:workflow-name:start
+name: Ossplate publish-npm
+# ossplate:workflow-name:end
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish-npm:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+          cache: npm
+          cache-dependency-path: ./wrapper-js/package-lock.json
+      - name: Detect published version
+        id: published
+        working-directory: ./wrapper-js
+        run: |
+          NAME=$(node -p "require('./package.json').name")
+          VERSION=$(node -p "require('./package.json').version")
+          echo "name=$NAME" >> "$GITHUB_OUTPUT"
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          if npm view "$NAME@$VERSION" version >/dev/null 2>&1; then
+            echo "already=true" >> "$GITHUB_OUTPUT"
+            echo "::notice title=npm::${NAME}@${VERSION} is already published; skipping."
+          else
+            echo "already=false" >> "$GITHUB_OUTPUT"
+          fi
+      - if: steps.published.outputs.already != 'true'
+        run: npm ci
+        working-directory: ./wrapper-js
+      - if: steps.published.outputs.already != 'true'
+        run: npm publish --access public
+        working-directory: ./wrapper-js
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/scaffold/.github/workflows/publish.yml

@@ -0,0 +1,97 @@
+# ossplate:workflow-name:start
+name: Ossplate publishing
+# ossplate:workflow-name:end
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish-pypi:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Build wheel
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+          python -m build --wheel
+        working-directory: ./wrapper-py
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: ./wrapper-py/dist/
+          skip-existing: true
+
+  publish-cargo:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Authenticate with crates.io via OIDC
+        id: auth
+        continue-on-error: true
+        uses: rust-lang/crates-io-auth-action@v1
+      - name: Detect published crate version
+        id: version
+        working-directory: ./core-rs
+        run: |
+          CRATE_NAME=$(python3 - <<'PY'
+          import tomllib
+          with open("Cargo.toml", "rb") as f:
+              data = tomllib.load(f)
+          print(data["package"]["name"])
+          PY
+          )
+          CRATE_VERSION=$(python3 - <<'PY'
+          import tomllib
+          with open("Cargo.toml", "rb") as f:
+              data = tomllib.load(f)
+          print(data["package"]["version"])
+          PY
+          )
+          echo "name=$CRATE_NAME" >> "$GITHUB_OUTPUT"
+          echo "version=$CRATE_VERSION" >> "$GITHUB_OUTPUT"
+          if curl -fsSL "https://crates.io/api/v1/crates/${CRATE_NAME}/${CRATE_VERSION}" >/dev/null 2>&1; then
+            echo "already=true" >> "$GITHUB_OUTPUT"
+            echo "::notice title=cargo::${CRATE_NAME} ${CRATE_VERSION} is already published; skipping."
+          else
+            echo "already=false" >> "$GITHUB_OUTPUT"
+          fi
+      - name: Publish to crates.io
+        if: steps.version.outputs.already != 'true'
+        working-directory: ./core-rs
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ steps.auth.outputs.token || secrets.CARGO_TOKEN }}
+        run: |
+          if [ -n "${{ steps.auth.outputs.token }}" ]; then
+            echo "::notice title=cargo::using crates.io OIDC token from trusted publishing."
+          else
+            echo "::notice title=cargo::OIDC token unavailable; falling back to CARGO_TOKEN secret."
+          fi
+          set +e
+          cargo publish 2>&1 | tee cargo-publish.log
+          status=${PIPESTATUS[0]}
+          set -e
+          if [ "$status" -eq 0 ]; then
+            exit 0
+          fi
+          if grep -q "status 429 Too Many Requests" cargo-publish.log; then
+            echo "::warning title=cargo::crates.io rate limit hit. Treating this publish attempt as non-blocking."
+            exit 0
+          fi
+          if grep -qi "already exists on crates.io index" cargo-publish.log; then
+            echo "::notice title=cargo::crate version already exists; skipping."
+            exit 0
+          fi
+          exit "$status"

package/scaffold/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+.venv/
+__pycache__/
+*.pyc
+.tmp-*/
+dist/
+build/
+node_modules/
+target/

package/scaffold/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+# Contributing
+
+Use the root verification flow before committing changes:
+
+```bash
+./scripts/verify.sh
+```
+
+That script mirrors the local release-confidence gate:
+
+- Rust format, clippy, and tests
+- `ossplate validate` and `ossplate sync --check`
+- JavaScript wrapper tests and package dry-run
+- Python wrapper tests
+
+Useful operator commands:
+
+```bash
+cargo run --manifest-path core-rs/Cargo.toml -- validate
+cargo run --manifest-path core-rs/Cargo.toml -- sync --check
+cargo run --manifest-path core-rs/Cargo.toml -- sync
+```
+
+Current ownership model:
+
+- `ossplate.toml` is the canonical identity source
+- `sync` owns Rust/npm/Python metadata surfaces
+- `sync` owns the root `README.md` identity block between `ossplate:readme-identity` markers
+- `sync` owns the top-level workflow display names between `ossplate:workflow-name` markers
+- workflow logic, auth, triggers, and job structure remain manual

package/scaffold/LICENSE

@@ -0,0 +1,9 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.
+
+In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

package/scaffold/README.md

@@ -0,0 +1,73 @@
+<!-- ossplate:readme-identity:start -->
+# Ossplate
+
+A practical baseline for shipping one project across Cargo, npm, and PyPI without starting from scratch every time.
+<!-- ossplate:readme-identity:end -->
+
+## What This Tool Gives You
+
+- a canonical Rust CLI in [`core-rs/`](./core-rs)
+- a thin npm wrapper in [`wrapper-js/`](./wrapper-js)
+- a thin Python wrapper in [`wrapper-py/`](./wrapper-py)
+- normal `push` / `pull_request` CI
+- rerun-safe publish workflows for npm, PyPI, and Cargo
+- setup and upgrade docs in [`docs/`](./docs/README.md)
+
+## Philosophy
+
+This project is intentionally small.
+
+It exists to validate and synchronize the shared identity of a multi-registry OSS scaffold before broader scaffolding features are added.
+
+## Core Commands
+
+```bash
+cargo run --manifest-path core-rs/Cargo.toml -- validate
+cargo run --manifest-path core-rs/Cargo.toml -- sync --check
+cargo run --manifest-path core-rs/Cargo.toml -- create ../my-new-project
+cargo run --manifest-path core-rs/Cargo.toml -- init --path ../existing-project
+```
+
+Wrapper installs expose the same command surface as `ossplate`.
+
+`create` and `init` now work from packaged wrapper artifacts as well as a source checkout. Installed wrappers carry a curated scaffold payload rather than a broad repo snapshot. Use flags to set the project identity during scaffold creation instead of editing `ossplate.toml` by hand first:
+
+```bash
+cargo run --manifest-path core-rs/Cargo.toml -- create ../my-new-project \
+  --name "My Project" \
+  --repository "https://github.com/acme/my-project" \
+  --author-name "Acme" \
+  --author-email "oss@acme.dev" \
+  --rust-crate "my-project" \
+  --npm-package "@acme/my-project" \
+  --python-package "my-project-py" \
+  --command "my-project"
+```
+
+## Local Verify
+
+Run the full local verification flow with:
+
+```bash
+./scripts/verify.sh
+```
+
+This is the recommended local mirror of the CI gate.
+
+## Verification
+
+- local workflow and layered testing guidance live in [docs/testing.md](./docs/testing.md)
+- contributor workflow lives in [CONTRIBUTING.md](./CONTRIBUTING.md)
+- `ossplate validate` reports owned metadata drift
+- `ossplate sync --check` fails if owned metadata would be rewritten
+- JS and Python artifact tests prove installed distributions can run `version`, `create`, and `validate`
+
+## Release Auth
+
+- PyPI publishes from [`.github/workflows/publish.yml`](./.github/workflows/publish.yml) via GitHub OIDC trusted publishing
+- Cargo publishes from [`.github/workflows/publish.yml`](./.github/workflows/publish.yml) via OIDC trusted publishing with `secrets.CARGO_TOKEN` as fallback
+- npm publishes from [`.github/workflows/publish-npm.yml`](./.github/workflows/publish-npm.yml) with `secrets.NPM_TOKEN`
+
+## License
+
+Licensed under the [Unlicense](LICENSE).