gaji 0.1.0

package/bin/gaji.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+const { execFileSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const PLATFORMS = {
+  "linux-x64": "@gaji/linux-x64",
+  "linux-arm64": "@gaji/linux-arm64",
+  "darwin-x64": "@gaji/darwin-x64",
+  "darwin-arm64": "@gaji/darwin-arm64",
+  "win32-x64": "@gaji/win32-x64",
+};
+
+function getBinaryPath() {
+  const override = process.env.GAJI_BINARY_PATH;
+  if (override) {
+    return override;
+  }
+
+  const platformKey = `${process.platform}-${process.arch}`;
+  const packageName = PLATFORMS[platformKey];
+
+  if (!packageName) {
+    console.error(
+      `Unsupported platform: ${platformKey}\n` +
+        `gaji supports: ${Object.keys(PLATFORMS).join(", ")}\n` +
+        `You can install from source: cargo install gaji`
+    );
+    process.exit(1);
+  }
+
+  const binName = process.platform === "win32" ? "gaji.exe" : "gaji";
+
+  try {
+    const pkgPath = require.resolve(`${packageName}/package.json`);
+    const binPath = path.join(path.dirname(pkgPath), "bin", binName);
+    if (fs.existsSync(binPath)) {
+      return binPath;
+    }
+  } catch (_) {
+    // Package not found
+  }
+
+  console.error(
+    `Could not find gaji binary for ${platformKey}.\n` +
+      `The platform package ${packageName} may not have been installed.\n` +
+      `Try: npm install ${packageName}\n` +
+      `Or install from source: cargo install gaji`
+  );
+  process.exit(1);
+}
+
+try {
+  const binPath = getBinaryPath();
+  execFileSync(binPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+  });
+} catch (e) {
+  if (e.status !== undefined) {
+    process.exit(e.status);
+  }
+  console.error(e.message);
+  process.exit(1);
+}

package/lib/base.d.ts

@@ -0,0 +1,143 @@
+// Base types for gaji
+// Auto-generated - Do not edit manually
+
+export interface JobStep {
+    name?: string;
+    uses?: string;
+    with?: Record<string, unknown>;
+    run?: string;
+    id?: string;
+    if?: string;
+    env?: Record<string, string>;
+    'working-directory'?: string;
+    shell?: string;
+    'continue-on-error'?: boolean;
+    'timeout-minutes'?: number;
+}
+
+export type Step = JobStep;
+
+export interface JobDefinition {
+    'runs-on': string | string[];
+    needs?: string | string[];
+    if?: string;
+    steps: JobStep[];
+    env?: Record<string, string>;
+    defaults?: {
+        run?: {
+            shell?: string;
+            'working-directory'?: string;
+        };
+    };
+    strategy?: {
+        matrix?: Record<string, unknown>;
+        'fail-fast'?: boolean;
+        'max-parallel'?: number;
+    };
+    'continue-on-error'?: boolean;
+    'timeout-minutes'?: number;
+    services?: Record<string, Service>;
+    container?: Container;
+    outputs?: Record<string, string>;
+    permissions?: Permissions;
+}
+
+export interface Service {
+    image: string;
+    credentials?: {
+        username: string;
+        password: string;
+    };
+    env?: Record<string, string>;
+    ports?: (string | number)[];
+    volumes?: string[];
+    options?: string;
+}
+
+export interface Container {
+    image: string;
+    credentials?: {
+        username: string;
+        password: string;
+    };
+    env?: Record<string, string>;
+    ports?: (string | number)[];
+    volumes?: string[];
+    options?: string;
+}
+
+export type Permissions = 'read-all' | 'write-all' | {
+    actions?: 'read' | 'write' | 'none';
+    checks?: 'read' | 'write' | 'none';
+    contents?: 'read' | 'write' | 'none';
+    deployments?: 'read' | 'write' | 'none';
+    'id-token'?: 'read' | 'write' | 'none';
+    issues?: 'read' | 'write' | 'none';
+    packages?: 'read' | 'write' | 'none';
+    'pull-requests'?: 'read' | 'write' | 'none';
+    'repository-projects'?: 'read' | 'write' | 'none';
+    'security-events'?: 'read' | 'write' | 'none';
+    statuses?: 'read' | 'write' | 'none';
+};
+
+export interface WorkflowTrigger {
+    branches?: string[];
+    'branches-ignore'?: string[];
+    tags?: string[];
+    'tags-ignore'?: string[];
+    paths?: string[];
+    'paths-ignore'?: string[];
+    types?: string[];
+}
+
+export interface ScheduleTrigger {
+    cron: string;
+}
+
+export interface WorkflowDispatchInput {
+    description?: string;
+    required?: boolean;
+    default?: string;
+    type?: 'string' | 'boolean' | 'choice' | 'environment';
+    options?: string[];
+}
+
+export interface WorkflowOn {
+    push?: WorkflowTrigger;
+    pull_request?: WorkflowTrigger;
+    pull_request_target?: WorkflowTrigger;
+    schedule?: ScheduleTrigger[];
+    workflow_dispatch?: {
+        inputs?: Record<string, WorkflowDispatchInput>;
+    };
+    workflow_call?: {
+        inputs?: Record<string, WorkflowDispatchInput>;
+        outputs?: Record<string, { description?: string; value: string }>;
+        secrets?: Record<string, { description?: string; required?: boolean }>;
+    };
+    release?: { types?: string[] };
+    issues?: { types?: string[] };
+    issue_comment?: { types?: string[] };
+    [key: string]: unknown;
+}
+
+export interface WorkflowConfig {
+    name?: string;
+    on: WorkflowOn;
+    env?: Record<string, string>;
+    defaults?: {
+        run?: {
+            shell?: string;
+            'working-directory'?: string;
+        };
+    };
+    concurrency?: {
+        group: string;
+        'cancel-in-progress'?: boolean;
+    } | string;
+    permissions?: Permissions;
+}
+
+export interface WorkflowDefinition extends WorkflowConfig {
+    jobs: Record<string, JobDefinition>;
+}

package/lib/index.d.ts

@@ -0,0 +1,92 @@
+// gaji runtime type declarations
+// https://github.com/gaji-ts/gaji
+
+import type {
+    JobStep,
+    JobDefinition,
+    WorkflowConfig,
+    WorkflowDefinition,
+    Permissions,
+} from './base';
+
+export declare function getAction<T extends string>(
+    ref: T
+): (config?: {
+    name?: string;
+    with?: Record<string, unknown>;
+    id?: string;
+    if?: string;
+    env?: Record<string, string>;
+}) => JobStep;
+
+export declare class Job {
+    constructor(runsOn: string | string[], options?: Partial<JobDefinition>);
+    addStep(step: JobStep): this;
+    needs(deps: string | string[]): this;
+    env(env: Record<string, string>): this;
+    when(condition: string): this;
+    permissions(perms: Permissions): this;
+    outputs(outputs: Record<string, string>): this;
+    strategy(s: {
+        matrix?: Record<string, unknown>;
+        'fail-fast'?: boolean;
+        'max-parallel'?: number;
+    }): this;
+    continueOnError(v: boolean): this;
+    timeoutMinutes(m: number): this;
+    toJSON(): JobDefinition;
+}
+
+export declare class Workflow {
+    constructor(config: WorkflowConfig);
+    addJob(id: string, job: Job): this;
+    static fromObject(def: WorkflowDefinition, id?: string): Workflow;
+    toJSON(): WorkflowDefinition;
+    build(id?: string): void;
+}
+
+export declare class CompositeAction {
+    constructor(config: {
+        name: string;
+        description: string;
+        inputs?: Record<string, unknown>;
+        outputs?: Record<string, unknown>;
+    });
+    addStep(step: JobStep): this;
+    toJSON(): object;
+    build(id?: string): void;
+}
+
+export declare class CallJob {
+    constructor(uses: string);
+    with(inputs: Record<string, unknown>): this;
+    secrets(s: Record<string, unknown> | 'inherit'): this;
+    needs(deps: string | string[]): this;
+    when(condition: string): this;
+    permissions(perms: Permissions): this;
+    toJSON(): object;
+}
+
+export declare class CallAction {
+    constructor(uses: string);
+    static from(action: CompositeAction): CallAction;
+    toJSON(): JobStep;
+}
+
+export type {
+    JobStep,
+    JobStep as Step,
+    JobDefinition,
+    WorkflowConfig,
+    WorkflowDefinition,
+    Permissions,
+} from './base';
+
+export type {
+    Service,
+    Container,
+    WorkflowTrigger,
+    ScheduleTrigger,
+    WorkflowDispatchInput,
+    WorkflowOn,
+} from './base';

package/lib/index.js

@@ -0,0 +1,187 @@
+// gaji runtime library
+// https://github.com/gaji-ts/gaji
+
+export function getAction(ref) {
+    return function(config) {
+        if (config === undefined) config = {};
+        var step = {
+            uses: ref,
+        };
+        if (config.name !== undefined) step.name = config.name;
+        if (config.with !== undefined) step.with = config.with;
+        if (config.id !== undefined) step.id = config.id;
+        if (config["if"] !== undefined) step["if"] = config["if"];
+        if (config.env !== undefined) step.env = config.env;
+        return step;
+    };
+}
+
+export class Job {
+    constructor(runsOn, options) {
+        if (options === undefined) options = {};
+        this._runsOn = runsOn;
+        this._steps = [];
+        this._needs = options.needs;
+        this._env = options.env;
+        this._if = options["if"];
+        this._permissions = options.permissions;
+        this._outputs = options.outputs;
+        this._strategy = options.strategy;
+        this._continueOnError = options["continue-on-error"];
+        this._timeoutMinutes = options["timeout-minutes"];
+        this._defaults = options.defaults;
+        this._services = options.services;
+        this._container = options.container;
+    }
+
+    addStep(step) { this._steps.push(step); return this; }
+    needs(deps) { this._needs = deps; return this; }
+    env(e) { this._env = e; return this; }
+    when(condition) { this._if = condition; return this; }
+    permissions(p) { this._permissions = p; return this; }
+    outputs(o) { this._outputs = o; return this; }
+    strategy(s) { this._strategy = s; return this; }
+    continueOnError(v) { this._continueOnError = v; return this; }
+    timeoutMinutes(m) { this._timeoutMinutes = m; return this; }
+
+    toJSON() {
+        var obj = {
+            "runs-on": this._runsOn,
+            steps: this._steps,
+        };
+        if (this._needs !== undefined) obj.needs = this._needs;
+        if (this._env !== undefined) obj.env = this._env;
+        if (this._if !== undefined) obj["if"] = this._if;
+        if (this._permissions !== undefined) obj.permissions = this._permissions;
+        if (this._outputs !== undefined) obj.outputs = this._outputs;
+        if (this._strategy !== undefined) obj.strategy = this._strategy;
+        if (this._continueOnError !== undefined) obj["continue-on-error"] = this._continueOnError;
+        if (this._timeoutMinutes !== undefined) obj["timeout-minutes"] = this._timeoutMinutes;
+        if (this._defaults !== undefined) obj.defaults = this._defaults;
+        if (this._services !== undefined) obj.services = this._services;
+        if (this._container !== undefined) obj.container = this._container;
+        return obj;
+    }
+}
+
+export class Workflow {
+    constructor(config) {
+        this._name = config.name;
+        this._on = config.on;
+        this._env = config.env;
+        this._defaults = config.defaults;
+        this._concurrency = config.concurrency;
+        this._permissions = config.permissions;
+        this._jobs = {};
+    }
+
+    addJob(id, job) {
+        this._jobs[id] = job;
+        return this;
+    }
+
+    static fromObject(def, id) {
+        var wf = new Workflow({ name: id, on: {} });
+        wf.__rawDef = def;
+        return wf;
+    }
+
+    toJSON() {
+        if (this.__rawDef) return this.__rawDef;
+        var obj = {};
+        if (this._name !== undefined) obj.name = this._name;
+        obj.on = this._on;
+        if (this._env !== undefined) obj.env = this._env;
+        if (this._defaults !== undefined) obj.defaults = this._defaults;
+        if (this._concurrency !== undefined) obj.concurrency = this._concurrency;
+        if (this._permissions !== undefined) obj.permissions = this._permissions;
+        obj.jobs = this._jobs;
+        return obj;
+    }
+
+    build(id) {
+        if (typeof __gha_build !== "undefined") {
+            __gha_build(id || "workflow", JSON.stringify(this), "workflow");
+        } else {
+            console.log(JSON.stringify(this, null, 2));
+        }
+    }
+}
+
+export class CompositeAction {
+    constructor(config) {
+        this._name = config.name;
+        this._description = config.description;
+        this._inputs = config.inputs;
+        this._outputs = config.outputs;
+        this._steps = [];
+        this._buildId = undefined;
+    }
+
+    addStep(step) { this._steps.push(step); return this; }
+
+    toJSON() {
+        var obj = {
+            name: this._name,
+            description: this._description,
+            runs: {
+                using: "composite",
+                steps: this._steps,
+            }
+        };
+        if (this._inputs !== undefined) obj.inputs = this._inputs;
+        if (this._outputs !== undefined) obj.outputs = this._outputs;
+        return obj;
+    }
+
+    build(id) {
+        this._buildId = id || "action";
+        if (typeof __gha_build !== "undefined") {
+            __gha_build(this._buildId, JSON.stringify(this), "action");
+        } else {
+            console.log(JSON.stringify(this, null, 2));
+        }
+    }
+}
+
+export class CallJob {
+    constructor(uses) {
+        this._uses = uses;
+        this._with = undefined;
+        this._secrets = undefined;
+        this._needs = undefined;
+        this._if = undefined;
+        this._permissions = undefined;
+    }
+
+    with(inputs) { this._with = inputs; return this; }
+    secrets(s) { this._secrets = s; return this; }
+    needs(deps) { this._needs = deps; return this; }
+    when(condition) { this._if = condition; return this; }
+    permissions(p) { this._permissions = p; return this; }
+
+    toJSON() {
+        var obj = { uses: this._uses };
+        if (this._with !== undefined) obj.with = this._with;
+        if (this._secrets !== undefined) obj.secrets = this._secrets;
+        if (this._needs !== undefined) obj.needs = this._needs;
+        if (this._if !== undefined) obj["if"] = this._if;
+        if (this._permissions !== undefined) obj.permissions = this._permissions;
+        return obj;
+    }
+}
+
+export class CallAction {
+    constructor(uses) {
+        this._uses = uses;
+    }
+
+    static from(compositeAction) {
+        var path = "./.github/actions/" + (compositeAction._buildId || compositeAction._name);
+        return new CallAction(path);
+    }
+
+    toJSON() {
+        return { uses: this._uses };
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "gaji",
+  "version": "0.1.0",
+  "description": "Type-safe GitHub Actions workflows in TypeScript",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gaji-ts/gaji"
+  },
+  "bin": {
+    "gaji": "bin/gaji.js"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./base": {
+      "types": "./lib/base.d.ts"
+    }
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "optionalDependencies": {
+    "@gaji/linux-x64": "0.1.0",
+    "@gaji/linux-arm64": "0.1.0",
+    "@gaji/darwin-x64": "0.1.0",
+    "@gaji/darwin-arm64": "0.1.0",
+    "@gaji/win32-x64": "0.1.0"
+  },
+  "keywords": [
+    "github-actions",
+    "typescript",
+    "ci-cd",
+    "workflow",
+    "type-safe"
+  ]
+}

package/scripts/postinstall.js

@@ -0,0 +1,29 @@
+const PLATFORMS = {
+  "linux-x64": "@gaji/linux-x64",
+  "linux-arm64": "@gaji/linux-arm64",
+  "darwin-x64": "@gaji/darwin-x64",
+  "darwin-arm64": "@gaji/darwin-arm64",
+  "win32-x64": "@gaji/win32-x64",
+};
+
+const platformKey = `${process.platform}-${process.arch}`;
+const packageName = PLATFORMS[platformKey];
+
+if (!packageName) {
+  console.warn(
+    `[gaji] Warning: Unsupported platform ${platformKey}. ` +
+      `The CLI binary will not be available. ` +
+      `Install from source: cargo install gaji`
+  );
+  process.exit(0);
+}
+
+try {
+  require.resolve(`${packageName}/package.json`);
+} catch (_) {
+  console.warn(
+    `[gaji] Warning: Platform package ${packageName} was not installed. ` +
+      `This can happen with --no-optional. ` +
+      `The CLI binary will not work, but the runtime library is still available.`
+  );
+}