cookout 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cookout contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

package/README.md

@@ -0,0 +1,57 @@
+# cookout
+
+Release readiness for packages, CLIs, and services.
+
+Cookout will help run checks like:
+
+- typecheck
+- lint
+- tests
+- smoke tests
+- package artifact checks
+- install-from-tarball checks
+- README snippet checks
+- release metadata checks
+
+For now, the package exposes a small CLI and config helper while the real runner takes shape.
+
+## Use
+
+```sh
+npx cookout@alpha check
+```
+
+## Install
+
+```sh
+npm install --save-dev cookout@alpha
+```
+
+## CLI
+
+```sh
+cookout check
+cookout check --json
+```
+
+`cookout check` currently prints the release-readiness checks Cookout plans to support. It exits successfully without running project commands while the runner is still in alpha.
+
+## Config Helper
+
+```js
+const { defineCookoutConfig } = require('cookout');
+
+module.exports = defineCookoutConfig({
+  project: 'cli',
+  packageManager: 'npm',
+  checks: [
+    'typecheck',
+    'lint',
+    'tests',
+    {
+      id: 'smoke',
+      command: 'npm run smoke:cli',
+    },
+  ],
+});
+```

package/bin/cookout.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../dist/cli.js');

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const index_1 = require("./index");
+main();
+function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.help) {
+        process.stdout.write(helpText());
+        return;
+    }
+    if (parsed.version) {
+        process.stdout.write(`${packageVersion()}\n`);
+        return;
+    }
+    if (parsed.command !== 'check') {
+        process.stderr.write(`Unknown command: ${parsed.command}\n\n${helpText()}`);
+        process.exitCode = 1;
+        return;
+    }
+    const plan = (0, index_1.createCheckPlan)();
+    if (parsed.json) {
+        process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`${(0, index_1.formatCheckPlan)(plan)}\n`);
+}
+function parseArgs(args) {
+    const parsed = {
+        command: 'check',
+        help: false,
+        json: false,
+        version: false,
+    };
+    const positional = [];
+    for (const arg of args) {
+        if (arg === '--help' || arg === '-h') {
+            parsed.help = true;
+        }
+        else if (arg === '--version' || arg === '-v') {
+            parsed.version = true;
+        }
+        else if (arg === '--json') {
+            parsed.json = true;
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    parsed.command = positional[0] ?? parsed.command;
+    return parsed;
+}
+function helpText() {
+    return `cookout ${packageVersion()}
+
+Release readiness for packages, CLIs, and services.
+
+Usage:
+  cookout check
+  cookout check --json
+
+Options:
+  --json              Print the planned checks as JSON
+  -v, --version       Print the package version
+  -h, --help          Show this help
+`;
+}
+function packageVersion() {
+    const packageJsonPath = (0, node_path_1.join)(__dirname, '..', 'package.json');
+    const rawPackageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, 'utf8'));
+    if (isPackageMetadata(rawPackageJson)) {
+        return rawPackageJson.version;
+    }
+    return '0.0.0';
+}
+function isPackageMetadata(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.version === 'string';
+}

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+export declare const checkCatalog: readonly [{
+    readonly id: "typecheck";
+    readonly label: "Typecheck";
+    readonly description: "Run the project type checker.";
+}, {
+    readonly id: "lint";
+    readonly label: "Lint";
+    readonly description: "Run static analysis and style checks.";
+}, {
+    readonly id: "tests";
+    readonly label: "Tests";
+    readonly description: "Run the automated test suite.";
+}, {
+    readonly id: "smoke";
+    readonly label: "Smoke tests";
+    readonly description: "Exercise the built package, CLI, or service in a real invocation.";
+}, {
+    readonly id: "package-artifact";
+    readonly label: "Package artifact checks";
+    readonly description: "Inspect the packed or built release artifact.";
+}, {
+    readonly id: "install-tarball";
+    readonly label: "Install-from-tarball checks";
+    readonly description: "Install the packed tarball into a fresh project and verify it loads.";
+}, {
+    readonly id: "readme-snippets";
+    readonly label: "README snippet checks";
+    readonly description: "Run documented examples so the README stays honest.";
+}, {
+    readonly id: "release-metadata";
+    readonly label: "Release metadata checks";
+    readonly description: "Validate package metadata, tags, files, engines, and release notes.";
+}];
+export type CookoutCheckId = typeof checkCatalog[number]['id'];
+export type CookoutProjectKind = 'cli' | 'package' | 'service';
+export interface CookoutCheckDefinition {
+    id: CookoutCheckId;
+    command?: string;
+    description?: string;
+}
+export interface CookoutConfig {
+    checks?: ReadonlyArray<CookoutCheckDefinition | CookoutCheckId>;
+    packageManager?: 'npm' | 'pnpm' | 'yarn' | 'bun';
+    project?: CookoutProjectKind;
+}
+export interface CookoutPlannedCheck {
+    id: CookoutCheckId;
+    label: string;
+    description: string;
+    command: string | null;
+}
+export interface CookoutCheckPlan {
+    packageManager: NonNullable<CookoutConfig['packageManager']>;
+    project: CookoutProjectKind;
+    status: 'planned';
+    checks: CookoutPlannedCheck[];
+}
+export declare function defineCookoutConfig(config: CookoutConfig): CookoutConfig;
+export declare function createCheckPlan(config?: CookoutConfig): CookoutCheckPlan;
+export declare function formatCheckPlan(plan: CookoutCheckPlan): string;

package/dist/index.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCatalog = void 0;
+exports.defineCookoutConfig = defineCookoutConfig;
+exports.createCheckPlan = createCheckPlan;
+exports.formatCheckPlan = formatCheckPlan;
+exports.checkCatalog = [
+    {
+        id: 'typecheck',
+        label: 'Typecheck',
+        description: 'Run the project type checker.',
+    },
+    {
+        id: 'lint',
+        label: 'Lint',
+        description: 'Run static analysis and style checks.',
+    },
+    {
+        id: 'tests',
+        label: 'Tests',
+        description: 'Run the automated test suite.',
+    },
+    {
+        id: 'smoke',
+        label: 'Smoke tests',
+        description: 'Exercise the built package, CLI, or service in a real invocation.',
+    },
+    {
+        id: 'package-artifact',
+        label: 'Package artifact checks',
+        description: 'Inspect the packed or built release artifact.',
+    },
+    {
+        id: 'install-tarball',
+        label: 'Install-from-tarball checks',
+        description: 'Install the packed tarball into a fresh project and verify it loads.',
+    },
+    {
+        id: 'readme-snippets',
+        label: 'README snippet checks',
+        description: 'Run documented examples so the README stays honest.',
+    },
+    {
+        id: 'release-metadata',
+        label: 'Release metadata checks',
+        description: 'Validate package metadata, tags, files, engines, and release notes.',
+    },
+];
+const DEFAULT_CHECKS = [
+    'typecheck',
+    'lint',
+    'tests',
+    'smoke',
+    'package-artifact',
+    'install-tarball',
+    'readme-snippets',
+    'release-metadata',
+];
+const DEFAULT_COMMANDS = {
+    typecheck: 'npm run check',
+    lint: 'npm run lint',
+    tests: 'npm test',
+    smoke: 'npm run smoke',
+    'package-artifact': 'npm pack --dry-run',
+    'install-tarball': 'npm pack && npm install <tarball>',
+    'readme-snippets': 'cookout check readme',
+    'release-metadata': 'cookout check metadata',
+};
+function defineCookoutConfig(config) {
+    return config;
+}
+function createCheckPlan(config = {}) {
+    const checks = config.checks ?? DEFAULT_CHECKS;
+    return {
+        packageManager: config.packageManager ?? 'npm',
+        project: config.project ?? 'package',
+        status: 'planned',
+        checks: checks.map(normalizeCheck),
+    };
+}
+function formatCheckPlan(plan) {
+    const header = [
+        'cookout check',
+        `project ${plan.project}`,
+        `package manager ${plan.packageManager}`,
+        `status ${plan.status}`,
+    ];
+    const rows = plan.checks.map((check) => {
+        const command = check.command ? ` -> ${check.command}` : '';
+        return `  - ${check.id}: ${check.label}${command}`;
+    });
+    return [
+        ...header,
+        '',
+        'Planned release-readiness checks:',
+        ...rows,
+        '',
+        'Runner execution is not wired yet in this alpha.',
+    ].join('\n');
+}
+function normalizeCheck(input) {
+    const candidate = typeof input === 'string' ? { id: input } : input;
+    const catalogEntry = exports.checkCatalog.find((entry) => entry.id === candidate.id);
+    if (!catalogEntry) {
+        throw new Error(`Unknown cookout check: ${candidate.id}`);
+    }
+    return {
+        id: catalogEntry.id,
+        label: catalogEntry.label,
+        description: candidate.description ?? catalogEntry.description,
+        command: candidate.command ?? DEFAULT_COMMANDS[catalogEntry.id],
+    };
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "cookout",
+  "version": "0.1.0-alpha.0",
+  "description": "Release readiness for packages, CLIs, and services.",
+  "author": "cookout contributors",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "cookout": "bin/cookout.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "tsc --noEmit",
+    "demo": "npm run build --silent && node ./bin/cookout.js check",
+    "lint": "eslint .",
+    "prepack": "npm run build",
+    "publish:alpha": "npm publish --tag alpha --access public",
+    "test": "npm run build --silent && vitest run",
+    "verify": "npm run check && npm run lint && npm test"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "cli",
+    "release",
+    "readiness",
+    "checks",
+    "testing",
+    "packaging",
+    "smoke-tests"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "eslint": "^10.6.0",
+    "eslint-config-rubric": "^0.1.0-alpha.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  }
+}