@rindrics/initrepo 0.0.1 → 0.1.4

package/src/templates/common/workflows/tagpr.yml.ejs

@@ -0,0 +1,31 @@
+name: tagpr
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  tagpr:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@<%= actionVersions['actions/checkout'] %>
+<% if (isDevcode) { -%>
+        # TODO: After replace-devcode, add token: ${{ secrets.PAT_FOR_TAGPR }}
+<% } else { -%>
+        with:
+          token: ${{ secrets.PAT_FOR_TAGPR }}
+<% } -%>
+
+      - uses: Songmu/tagpr@<%= actionVersions['Songmu/tagpr'] %>
+        env:
+<% if (isDevcode) { -%>
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # TODO: After replace-devcode, use PAT_FOR_TAGPR instead
+<% } else { -%>
+          GITHUB_TOKEN: ${{ secrets.PAT_FOR_TAGPR }}
+<% } -%>

package/src/templates/typescript/.tagpr.ejs

@@ -0,0 +1,5 @@
+# tagpr configuration
+# https://github.com/Songmu/tagpr
+
+[tagpr]
+versionFile = "package.json"

package/src/templates/typescript/codeql/codeql-config.yml.ejs

@@ -0,0 +1,7 @@
+name: "CodeQL config for <%= name %>"
+
+paths:
+  - src
+
+paths-ignore:
+  - node_modules/

package/src/templates/typescript/package.json.ejs

@@ -0,0 +1,29 @@
+{
+  "name": "<%= name %>",
+  "version": "0.0.0",
+<% if (isDevcode) { -%>
+  "private": true,
+<% } -%>
+  "description": "",
+  "type": "module",
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "lint": "biome lint src",
+    "format": "biome format src --write",
+    "check": "biome check src",
+    "test": "bun test",
+    "prepare": "husky"
+  },
+  "keywords": [],
+  "author": "<%= author %>",
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^<%= versions['@biomejs/biome'] %>",
+    "@commitlint/cli": "^<%= versions['@commitlint/cli'] %>",
+    "@commitlint/config-conventional": "^<%= versions['@commitlint/config-conventional'] %>",
+    "bun-types": "^<%= versions['bun-types'] %>",
+    "husky": "^<%= versions['husky'] %>",
+    "typescript": "^<%= versions['typescript'] %>"
+  }
+}

package/src/templates/typescript/src/index.ts.ejs

@@ -0,0 +1 @@
+console.log('Hello from <%= name %>!');

package/src/templates/typescript/tsconfig.json.ejs

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+

package/src/templates/typescript/workflows/ci.yml.ejs

@@ -0,0 +1,58 @@
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'src/**'
+      - 'package.json'
+      - 'tsconfig.json'
+      - 'biome.json'
+      - 'bun.lock'
+      - '.github/workflows/ci.yml'
+  push:
+    branches:
+      - main
+    paths:
+      - 'src/**'
+      - 'package.json'
+      - 'tsconfig.json'
+      - 'biome.json'
+      - 'bun.lock'
+      - '.github/workflows/ci.yml'
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@<%= actionVersions['actions/checkout'] %>
+
+      - uses: oven-sh/setup-bun@<%= actionVersions['oven-sh/setup-bun'] %>
+        with:
+          bun-version: latest
+
+      - run: bun install --frozen-lockfile
+
+      - name: Biome check
+        run: bun run check
+
+      - name: TypeScript check
+        run: bun run build
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@<%= actionVersions['actions/checkout'] %>
+
+      - uses: oven-sh/setup-bun@<%= actionVersions['oven-sh/setup-bun'] %>
+        with:
+          bun-version: latest
+
+      - run: bun install --frozen-lockfile
+
+      - name: Test
+        run: bun test

package/src/templates/typescript/workflows/codeql.yml.ejs

@@ -0,0 +1,46 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'src/**'
+      - 'package.json'
+      - 'tsconfig.json'
+      - '.github/workflows/codeql.yml'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'src/**'
+      - 'package.json'
+      - 'tsconfig.json'
+      - '.github/workflows/codeql.yml'
+  schedule:
+    # Run weekly on Sunday at 00:00 UTC
+    - cron: '0 0 * * 0'
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@<%= actionVersions['actions/checkout'] %>
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@<%= actionVersions['github/codeql-action'] %>
+        with:
+          languages: javascript-typescript
+          config-file: ./.github/codeql/codeql-config.yml
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@<%= actionVersions['github/codeql-action'] %>
+        with:
+          category: '/language:javascript-typescript'

package/src/types.ts

@@ -0,0 +1,13 @@
+export type Language = 'typescript';
+
+export interface InitOptions {
+  /** The name used for npm publish (e.g., @scope/package-name) */
+  projectName: string;
+  lang: Language;
+  /** If true, projectName is a development code that will be replaced later */
+  isDevcode: boolean;
+  /** Optional output directory path. Defaults to projectName if not specified. */
+  targetDir?: string;
+  /** Package author. If not specified, detected from language-specific tools (e.g., npm whoami for TypeScript). */
+  author?: string;
+}

package/src/utils/github-repo.test.ts

@@ -0,0 +1,34 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { hasGitHubToken } from './github-repo';
+
+describe('github-repo utils', () => {
+  describe('hasGitHubToken', () => {
+    const originalToken = process.env.GITHUB_TOKEN;
+
+    afterEach(() => {
+      if (originalToken !== undefined) {
+        process.env.GITHUB_TOKEN = originalToken;
+      } else {
+        delete process.env.GITHUB_TOKEN;
+      }
+    });
+
+    test('should return true when GITHUB_TOKEN is set', () => {
+      process.env.GITHUB_TOKEN = 'test-token';
+      expect(hasGitHubToken()).toBe(true);
+    });
+
+    test('should return false when GITHUB_TOKEN is not set', () => {
+      delete process.env.GITHUB_TOKEN;
+      expect(hasGitHubToken()).toBe(false);
+    });
+
+    test('should return false when GITHUB_TOKEN is empty', () => {
+      process.env.GITHUB_TOKEN = '';
+      expect(hasGitHubToken()).toBe(false);
+    });
+  });
+
+  // Note: createGitHubRepo is not tested here because it requires
+  // actual GitHub API calls. Integration tests should be done separately.
+});

package/src/utils/github-repo.ts

@@ -0,0 +1,141 @@
+import { Octokit } from 'octokit';
+
+export interface CreateRepoOptions {
+  name: string;
+  description?: string;
+  isPrivate: boolean;
+}
+
+export interface GitHubRepoResult {
+  url: string;
+  cloneUrl: string;
+  alreadyExisted: boolean;
+}
+
+/**
+ * Labels required for tagpr workflow
+ */
+const TAGPR_LABELS = [
+  {
+    name: 'tagpr:minor',
+    color: '0e8a16',
+    description: 'have tagpr bump minor version',
+  },
+  {
+    name: 'tagpr:major',
+    color: 'd93f0b',
+    description: 'have tagpr bump major version',
+  },
+] as const;
+
+export class RepoAlreadyExistsError extends Error {
+  constructor(
+    public readonly repoName: string,
+    public readonly repoUrl: string,
+    public readonly cloneUrl: string,
+  ) {
+    super(`Repository "${repoName}" already exists`);
+    this.name = 'RepoAlreadyExistsError';
+  }
+}
+
+/**
+ * Creates a GitHub repository and sets up tagpr labels
+ */
+export async function createGitHubRepo(
+  options: CreateRepoOptions,
+): Promise<GitHubRepoResult> {
+  const token = process.env.GITHUB_TOKEN;
+
+  if (!token) {
+    throw new Error(
+      'GITHUB_TOKEN environment variable is required for repository creation',
+    );
+  }
+
+  const octokit = new Octokit({ auth: token });
+
+  // Get authenticated user
+  const { data: user } = await octokit.rest.users.getAuthenticated();
+
+  let repoUrl: string;
+  let cloneUrl: string;
+  let alreadyExisted = false;
+
+  // Create repository
+  try {
+    const { data: repo } = await octokit.rest.repos.createForAuthenticatedUser({
+      name: options.name,
+      description: options.description ?? '',
+      private: options.isPrivate,
+      auto_init: false,
+    });
+    repoUrl = repo.html_url;
+    cloneUrl = repo.clone_url;
+  } catch (error) {
+    const apiError = error as { status?: number; message?: string };
+
+    // Repository already exists (422 Unprocessable Entity)
+    if (apiError.status === 422) {
+      // Fetch existing repo info
+      try {
+        const { data: existingRepo } = await octokit.rest.repos.get({
+          owner: user.login,
+          repo: options.name,
+        });
+        repoUrl = existingRepo.html_url;
+        cloneUrl = existingRepo.clone_url;
+        alreadyExisted = true;
+      } catch {
+        throw new Error(
+          `Repository "${options.name}" already exists but could not fetch its details`,
+        );
+      }
+    } else {
+      throw error;
+    }
+  }
+
+  // Create tagpr labels (skip silently if already exist)
+  await createTagprLabels(octokit, user.login, options.name);
+
+  return {
+    url: repoUrl,
+    cloneUrl,
+    alreadyExisted,
+  };
+}
+
+/**
+ * Creates tagpr labels for a repository
+ */
+async function createTagprLabels(
+  octokit: Octokit,
+  owner: string,
+  repo: string,
+): Promise<void> {
+  for (const label of TAGPR_LABELS) {
+    try {
+      await octokit.rest.issues.createLabel({
+        owner,
+        repo,
+        name: label.name,
+        color: label.color,
+        description: label.description,
+      });
+    } catch (error) {
+      // Label already exists (422), ignore
+      const apiError = error as { status?: number };
+      if (apiError.status !== 422) {
+        throw error;
+      }
+    }
+  }
+}
+
+/**
+ * Checks if GITHUB_TOKEN is available
+ */
+export function hasGitHubToken(): boolean {
+  return !!process.env.GITHUB_TOKEN;
+}

package/src/utils/github.ts

@@ -0,0 +1,47 @@
+import { DEFAULT_ACTION_VERSION, GITHUB_ACTIONS } from '../config';
+
+/**
+ * Fetches the latest major version tag for a GitHub Action
+ * @param repo - Repository in format "owner/repo" (e.g., "actions/checkout")
+ * @returns Latest major version tag (e.g., "v4")
+ */
+export async function getLatestActionVersion(repo: string): Promise<string> {
+  const response = await fetch(
+    `https://api.github.com/repos/${repo}/releases/latest`,
+  );
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch latest release for ${repo}`);
+  }
+
+  const data = (await response.json()) as { tag_name: string };
+  // Extract major version (e.g., "v4.2.0" -> "v4")
+  const match = data.tag_name.match(/^v?(\d+)/);
+  return match ? `v${match[1]}` : data.tag_name;
+}
+
+/**
+ * Fetches latest major versions for all configured GitHub Actions
+ */
+export async function getLatestActionVersions(
+  actions: readonly string[] = Object.keys(GITHUB_ACTIONS),
+): Promise<Record<string, string>> {
+  const versions: Record<string, string> = {};
+
+  await Promise.all(
+    actions.map(async (action) => {
+      try {
+        versions[action] = await getLatestActionVersion(action);
+      } catch {
+        versions[action] =
+          GITHUB_ACTIONS[action as keyof typeof GITHUB_ACTIONS] ??
+          DEFAULT_ACTION_VERSION;
+      }
+    }),
+  );
+
+  return versions;
+}
+
+// Re-export for convenience
+export { GITHUB_ACTIONS };

package/src/utils/npm.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test';
+import { getLatestVersion, getLatestVersions, getNpmUsername } from './npm';
+
+describe('npm utils', () => {
+  describe('getLatestVersion', () => {
+    const originalFetch = globalThis.fetch;
+
+    afterEach(() => {
+      globalThis.fetch = originalFetch;
+    });
+
+    test('should return version from npm registry', async () => {
+      globalThis.fetch = mock(() =>
+        Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve({ version: '1.2.3' }),
+        } as Response),
+      ) as unknown as typeof fetch;
+
+      const version = await getLatestVersion('some-package');
+      expect(version).toBe('1.2.3');
+    });
+
+    test('should throw error when fetch fails', async () => {
+      globalThis.fetch = mock(() =>
+        Promise.resolve({
+          ok: false,
+        } as Response),
+      ) as unknown as typeof fetch;
+
+      expect(getLatestVersion('some-package')).rejects.toThrow(
+        'Failed to fetch version',
+      );
+    });
+  });
+
+  describe('getLatestVersions', () => {
+    const originalFetch = globalThis.fetch;
+
+    afterEach(() => {
+      globalThis.fetch = originalFetch;
+    });
+
+    test('should return versions for multiple packages', async () => {
+      globalThis.fetch = mock((url: string) => {
+        const packageName = url.toString().split('/').slice(-2, -1)[0];
+        const versions: Record<string, string> = {
+          'package-a': '1.0.0',
+          'package-b': '2.0.0',
+        };
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve({ version: versions[packageName] }),
+        } as Response);
+      }) as unknown as typeof fetch;
+
+      const versions = await getLatestVersions(['package-a', 'package-b']);
+      expect(versions['package-a']).toBe('1.0.0');
+      expect(versions['package-b']).toBe('2.0.0');
+    });
+
+    test('should fallback to "latest" when fetch fails', async () => {
+      globalThis.fetch = mock(() =>
+        Promise.resolve({
+          ok: false,
+        } as Response),
+      ) as unknown as typeof fetch;
+
+      const versions = await getLatestVersions(['failing-package']);
+      expect(versions['failing-package']).toBe('latest');
+    });
+  });
+
+  describe('getNpmUsername', () => {
+    test('should return username when logged in', async () => {
+      const mockExec = mock(() =>
+        Promise.resolve({ stdout: 'mocked-user\n', stderr: '' }),
+      );
+
+      const username = await getNpmUsername(mockExec);
+      expect(username).toBe('mocked-user');
+      expect(mockExec).toHaveBeenCalledWith('npm whoami');
+    });
+
+    test('should return null when stdout is empty', async () => {
+      const mockExec = mock(() => Promise.resolve({ stdout: '', stderr: '' }));
+
+      const username = await getNpmUsername(mockExec);
+      expect(username).toBeNull();
+    });
+
+    test('should return null when npm whoami fails', async () => {
+      const mockExec = mock(() => Promise.reject(new Error('Not logged in')));
+
+      const username = await getNpmUsername(mockExec);
+      expect(username).toBeNull();
+    });
+  });
+});

package/src/utils/npm.ts

@@ -0,0 +1,59 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+
+type ExecFn = (command: string) => Promise<{ stdout: string; stderr: string }>;
+
+/**
+ * Fetches the latest version of a package from npm registry
+ */
+export async function getLatestVersion(packageName: string): Promise<string> {
+  const response = await fetch(
+    `https://registry.npmjs.org/${packageName}/latest`,
+  );
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch version for ${packageName}`);
+  }
+
+  const data = (await response.json()) as { version: string };
+  return data.version;
+}
+
+/**
+ * Gets the current npm username if logged in
+ * @param execFn - Optional exec function for testing (defaults to execAsync)
+ */
+export async function getNpmUsername(
+  execFn: ExecFn = execAsync,
+): Promise<string | null> {
+  try {
+    const { stdout } = await execFn('npm whoami');
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetches latest versions for multiple packages
+ */
+export async function getLatestVersions(
+  packageNames: string[],
+): Promise<Record<string, string>> {
+  const versions: Record<string, string> = {};
+
+  await Promise.all(
+    packageNames.map(async (name) => {
+      try {
+        versions[name] = await getLatestVersion(name);
+      } catch {
+        // Fallback to a default version if fetch fails
+        versions[name] = 'latest';
+      }
+    }),
+  );
+
+  return versions;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}