@rindrics/initrepo 0.0.1 → 0.1.4

package/src/generators/project.test.ts

@@ -0,0 +1,363 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { getLatestActionVersions } from '../utils/github';
+import * as npmUtils from '../utils/npm';
+import {
+  generateEntryPoint,
+  generatePackageJson,
+  generateProject,
+  generateTagprConfig,
+  generateTagprWorkflow,
+  generateTsconfig,
+  loadTemplate,
+  ProjectNameError,
+  TemplateError,
+  validateProjectName,
+  writeGeneratedFiles,
+} from './project';
+
+describe('project generator', () => {
+  const testDir = path.join(import.meta.dir, '../../.test-output');
+
+  beforeEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  describe('loadTemplate', () => {
+    test('should throw TemplateError for path traversal attempt', async () => {
+      expect(loadTemplate('../../../etc/passwd', {})).rejects.toThrow(
+        TemplateError,
+      );
+      expect(loadTemplate('../../../etc/passwd', {})).rejects.toThrow(
+        'resolves outside templates directory',
+      );
+    });
+
+    test('should throw TemplateError for non-existent template', async () => {
+      expect(loadTemplate('non-existent.ejs', {})).rejects.toThrow(
+        TemplateError,
+      );
+      expect(loadTemplate('non-existent.ejs', {})).rejects.toThrow(
+        'Template not found',
+      );
+    });
+
+    test('should load and render valid template', async () => {
+      const result = await loadTemplate('typescript/package.json.ejs', {
+        name: 'test',
+        author: '',
+        isDevcode: false,
+        versions: {
+          '@biomejs/biome': '1.0.0',
+          '@commitlint/cli': '1.0.0',
+          '@commitlint/config-conventional': '1.0.0',
+          'bun-types': '1.0.0',
+          husky: '1.0.0',
+          typescript: '1.0.0',
+        },
+      });
+
+      expect(result).toContain('"name": "test"');
+    });
+  });
+
+  describe('generatePackageJson', () => {
+    let getNpmUsernameSpy: ReturnType<typeof spyOn>;
+    let getLatestVersionsSpy: ReturnType<typeof spyOn>;
+
+    beforeEach(() => {
+      getNpmUsernameSpy = spyOn(npmUtils, 'getNpmUsername').mockResolvedValue(
+        'mocked-user',
+      );
+      getLatestVersionsSpy = spyOn(
+        npmUtils,
+        'getLatestVersions',
+      ).mockResolvedValue({
+        '@biomejs/biome': '1.0.0',
+        '@commitlint/cli': '1.0.0',
+        '@commitlint/config-conventional': '1.0.0',
+        'bun-types': '1.0.0',
+        husky: '1.0.0',
+        typescript: '1.0.0',
+      });
+    });
+
+    afterEach(() => {
+      getNpmUsernameSpy.mockRestore();
+      getLatestVersionsSpy.mockRestore();
+    });
+
+    test('should generate package.json with project name', async () => {
+      const result = await generatePackageJson({
+        projectName: 'my-awesome-project',
+        lang: 'typescript',
+        isDevcode: false,
+      });
+
+      expect(result.path).toBe('package.json');
+      expect(result.content).toContain('"name": "my-awesome-project"');
+    });
+
+    test('should include standard scripts', async () => {
+      const result = await generatePackageJson({
+        projectName: 'test-project',
+        lang: 'typescript',
+        isDevcode: false,
+      });
+
+      expect(result.content).toContain('"dev"');
+      expect(result.content).toContain('"build"');
+      expect(result.content).toContain('"test"');
+      expect(result.content).toContain('"check"');
+    });
+
+    test('should include mocked author', async () => {
+      const result = await generatePackageJson({
+        projectName: 'test-project',
+        lang: 'typescript',
+        isDevcode: false,
+      });
+
+      expect(result.content).toContain('"author": "mocked-user"');
+    });
+  });
+
+  describe('writeGeneratedFiles', () => {
+    test('should create directory and write files', async () => {
+      const files = [
+        { path: 'test.txt', content: 'hello world' },
+        { path: 'nested/file.txt', content: 'nested content' },
+      ];
+
+      await writeGeneratedFiles(testDir, files);
+
+      const file1 = await fs.readFile(path.join(testDir, 'test.txt'), 'utf-8');
+      const file2 = await fs.readFile(
+        path.join(testDir, 'nested/file.txt'),
+        'utf-8',
+      );
+
+      expect(file1).toBe('hello world');
+      expect(file2).toBe('nested content');
+    });
+  });
+
+  describe('validateProjectName', () => {
+    test('should accept valid project names', () => {
+      expect(() => validateProjectName('my-project')).not.toThrow();
+      expect(() => validateProjectName('my_project')).not.toThrow();
+      expect(() => validateProjectName('my-project-123')).not.toThrow();
+      expect(() => validateProjectName('@scope/my-project')).not.toThrow();
+      expect(() => validateProjectName('a')).not.toThrow();
+    });
+
+    test('should throw for empty project name', () => {
+      expect(() => validateProjectName('')).toThrow(ProjectNameError);
+      expect(() => validateProjectName('   ')).toThrow('cannot be empty');
+    });
+
+    test('should throw for path separators', () => {
+      expect(() => validateProjectName('my/project')).toThrow(ProjectNameError);
+      expect(() => validateProjectName('my\\project')).toThrow(
+        'invalid path separators',
+      );
+    });
+
+    test('should throw for leading/trailing dots', () => {
+      expect(() => validateProjectName('.my-project')).toThrow(
+        ProjectNameError,
+      );
+      expect(() => validateProjectName('my-project.')).toThrow(
+        'cannot start or end with a dot',
+      );
+    });
+
+    test('should throw for invalid characters', () => {
+      expect(() => validateProjectName('my project')).toThrow(ProjectNameError);
+      expect(() => validateProjectName('my$project')).toThrow(
+        'invalid characters',
+      );
+    });
+  });
+
+  describe('generateTsconfig', () => {
+    test('should generate tsconfig.json', async () => {
+      const result = await generateTsconfig({
+        projectName: 'test-project',
+        lang: 'typescript',
+        isDevcode: false,
+      });
+
+      expect(result.path).toBe('tsconfig.json');
+      expect(result.content).toContain('"target": "ES2022"');
+      expect(result.content).toContain('"moduleResolution": "bundler"');
+      expect(result.content).toContain('"bun-types"');
+    });
+  });
+
+  describe('generateEntryPoint', () => {
+    test('should generate src/index.ts with project name', async () => {
+      const result = await generateEntryPoint({
+        projectName: 'my-cool-project',
+        lang: 'typescript',
+        isDevcode: false,
+      });
+
+      expect(result.path).toBe('src/index.ts');
+      expect(result.content).toContain('my-cool-project');
+    });
+  });
+
+  describe('generateTagprConfig', () => {
+    test('should generate .tagpr with versionFile for TypeScript', async () => {
+      const result = await generateTagprConfig({
+        projectName: 'test-project',
+        lang: 'typescript',
+        isDevcode: false,
+      });
+
+      expect(result.path).toBe('.tagpr');
+      expect(result.content).toContain('versionFile = "package.json"');
+    });
+  });
+
+  describe('generateTagprWorkflow', () => {
+    // Helper to extract major version number from "vN" format
+    function extractMajorVersion(content: string, action: string): number {
+      const regex = new RegExp(`${action.replace('/', '\\/')}@v(\\d+)`);
+      const match = content.match(regex);
+      return match ? Number.parseInt(match[1], 10) : 0;
+    }
+
+    test('should generate tagpr.yml for devcode project', async () => {
+      const actionVersions = await getLatestActionVersions();
+      const result = await generateTagprWorkflow(
+        {
+          projectName: 'test-devcode',
+          lang: 'typescript',
+          isDevcode: true,
+        },
+        actionVersions,
+      );
+
+      expect(result.path).toBe('.github/workflows/tagpr.yml');
+      expect(result.content).toContain(
+        'GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}',
+      );
+      expect(result.content).toContain('# TODO: After replace-devcode');
+
+      // Version should be at least the minimum expected
+      expect(
+        extractMajorVersion(result.content, 'actions/checkout'),
+      ).toBeGreaterThanOrEqual(5);
+      expect(
+        extractMajorVersion(result.content, 'Songmu/tagpr'),
+      ).toBeGreaterThanOrEqual(1);
+    });
+
+    test('should generate tagpr.yml for production project', async () => {
+      const actionVersions = await getLatestActionVersions();
+      const result = await generateTagprWorkflow(
+        {
+          projectName: 'test-prod',
+          lang: 'typescript',
+          isDevcode: false,
+        },
+        actionVersions,
+      );
+
+      expect(result.path).toBe('.github/workflows/tagpr.yml');
+      expect(result.content).toContain(
+        'GITHUB_TOKEN: ${{ secrets.PAT_FOR_TAGPR }}',
+      );
+      expect(result.content).not.toContain('# TODO: After replace-devcode');
+
+      // Version should be at least the minimum expected
+      expect(
+        extractMajorVersion(result.content, 'actions/checkout'),
+      ).toBeGreaterThanOrEqual(4);
+      expect(
+        extractMajorVersion(result.content, 'Songmu/tagpr'),
+      ).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('generateProject', () => {
+    let getNpmUsernameSpy: ReturnType<typeof spyOn>;
+    let getLatestVersionsSpy: ReturnType<typeof spyOn>;
+
+    beforeEach(() => {
+      getNpmUsernameSpy = spyOn(npmUtils, 'getNpmUsername').mockResolvedValue(
+        'mocked-user',
+      );
+      getLatestVersionsSpy = spyOn(
+        npmUtils,
+        'getLatestVersions',
+      ).mockResolvedValue({
+        '@biomejs/biome': '1.0.0',
+        '@commitlint/cli': '1.0.0',
+        '@commitlint/config-conventional': '1.0.0',
+        'bun-types': '1.0.0',
+        husky: '1.0.0',
+        typescript: '1.0.0',
+      });
+    });
+
+    afterEach(() => {
+      getNpmUsernameSpy.mockRestore();
+      getLatestVersionsSpy.mockRestore();
+    });
+
+    test('should throw for invalid project name', async () => {
+      expect(
+        generateProject({
+          projectName: '../evil-path',
+          lang: 'typescript',
+          isDevcode: false,
+        }),
+      ).rejects.toThrow(ProjectNameError);
+    });
+
+    test('should use targetDir for output while keeping projectName for package.json', async () => {
+      const projectDir = path.join(testDir, 'new-project');
+
+      await generateProject({
+        projectName: 'new-project',
+        lang: 'typescript',
+        isDevcode: false,
+        targetDir: projectDir,
+      });
+
+      const packageJsonPath = path.join(projectDir, 'package.json');
+      const content = await fs.readFile(packageJsonPath, 'utf-8');
+      const pkg = JSON.parse(content);
+
+      expect(pkg.name).toBe('new-project');
+      expect(pkg.author).toBe('mocked-user');
+    });
+
+    test('should generate all expected files', async () => {
+      const projectDir = path.join(testDir, 'full-project');
+
+      await generateProject({
+        projectName: 'full-project',
+        lang: 'typescript',
+        isDevcode: true,
+        targetDir: projectDir,
+      });
+
+      // Check all files exist
+      const files = await fs.readdir(projectDir, { recursive: true });
+      expect(files).toContain('package.json');
+      expect(files).toContain('tsconfig.json');
+      expect(files).toContain('.tagpr');
+      expect(files).toContain(path.join('src', 'index.ts'));
+      expect(files).toContain(path.join('.github', 'workflows', 'tagpr.yml'));
+    });
+  });
+});

package/src/generators/project.ts

@@ -0,0 +1,300 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import ejs from 'ejs';
+import type { InitOptions } from '../types';
+import { getLatestActionVersions } from '../utils/github';
+import { getLatestVersions, getNpmUsername } from '../utils/npm';
+
+const TEMPLATES_DIR = path.join(import.meta.dir, '../templates');
+
+const DEV_DEPENDENCIES = [
+  '@biomejs/biome',
+  '@commitlint/cli',
+  '@commitlint/config-conventional',
+  'bun-types',
+  'husky',
+  'typescript',
+];
+
+export interface GeneratedFile {
+  path: string;
+  content: string;
+}
+
+export class TemplateError extends Error {
+  constructor(
+    message: string,
+    public readonly templatePath: string,
+    public readonly cause?: Error,
+  ) {
+    super(message);
+    this.name = 'TemplateError';
+  }
+}
+
+export async function loadTemplate(
+  templatePath: string,
+  data: Record<string, unknown>,
+): Promise<string> {
+  const resolvedTemplatesDir = path.resolve(TEMPLATES_DIR);
+  const fullPath = path.resolve(TEMPLATES_DIR, templatePath);
+
+  if (!fullPath.startsWith(resolvedTemplatesDir + path.sep)) {
+    throw new TemplateError(
+      `Invalid template path: "${templatePath}" resolves outside templates directory`,
+      templatePath,
+    );
+  }
+
+  let template: string;
+  try {
+    template = await fs.readFile(fullPath, 'utf-8');
+  } catch (error) {
+    const fsError = error as NodeJS.ErrnoException;
+    if (fsError.code === 'ENOENT') {
+      throw new TemplateError(
+        `Template not found: "${templatePath}"`,
+        templatePath,
+        fsError,
+      );
+    }
+    throw new TemplateError(
+      `Failed to read template "${templatePath}": ${fsError.message}`,
+      templatePath,
+      fsError,
+    );
+  }
+
+  try {
+    return ejs.render(template, data);
+  } catch (error) {
+    const renderError = error as Error;
+    throw new TemplateError(
+      `Failed to render template "${templatePath}": ${renderError.message}`,
+      templatePath,
+      renderError,
+    );
+  }
+}
+
+export async function generatePackageJson(
+  options: InitOptions,
+): Promise<GeneratedFile> {
+  try {
+    const [versions, detectedAuthor] = await Promise.all([
+      getLatestVersions(DEV_DEPENDENCIES),
+      options.author ? Promise.resolve(options.author) : getNpmUsername(),
+    ]);
+    const author = detectedAuthor ?? '';
+    const templatePath = `${options.lang}/package.json.ejs`;
+    const content = await loadTemplate(templatePath, {
+      name: options.projectName,
+      isDevcode: options.isDevcode,
+      author,
+      versions,
+    });
+    return { path: 'package.json', content };
+  } catch (error) {
+    throw new Error(
+      `Failed to generate package.json: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+export async function generateTsconfig(
+  options: InitOptions,
+): Promise<GeneratedFile> {
+  const content = await loadTemplate(`${options.lang}/tsconfig.json.ejs`, {});
+  return { path: 'tsconfig.json', content };
+}
+
+export async function generateEntryPoint(
+  options: InitOptions,
+): Promise<GeneratedFile> {
+  const content = await loadTemplate(`${options.lang}/src/index.ts.ejs`, {
+    name: options.projectName,
+  });
+  return { path: 'src/index.ts', content };
+}
+
+export async function generateTagprConfig(
+  options: InitOptions,
+): Promise<GeneratedFile> {
+  const content = await loadTemplate(`${options.lang}/.tagpr.ejs`, {});
+  return { path: '.tagpr', content };
+}
+
+export async function generateTagprWorkflow(
+  options: InitOptions,
+  actionVersions: Record<string, string>,
+): Promise<GeneratedFile> {
+  const content = await loadTemplate('common/workflows/tagpr.yml.ejs', {
+    isDevcode: options.isDevcode,
+    actionVersions,
+  });
+  return { path: '.github/workflows/tagpr.yml', content };
+}
+
+export async function generateCiWorkflow(
+  options: InitOptions,
+  actionVersions: Record<string, string>,
+): Promise<GeneratedFile> {
+  const content = await loadTemplate(`${options.lang}/workflows/ci.yml.ejs`, {
+    actionVersions,
+  });
+  return { path: '.github/workflows/ci.yml', content };
+}
+
+export async function generateCodeqlWorkflow(
+  options: InitOptions,
+  actionVersions: Record<string, string>,
+): Promise<GeneratedFile> {
+  const content = await loadTemplate(
+    `${options.lang}/workflows/codeql.yml.ejs`,
+    { actionVersions },
+  );
+  return { path: '.github/workflows/codeql.yml', content };
+}
+
+export async function generateCodeqlConfig(
+  options: InitOptions,
+): Promise<GeneratedFile> {
+  const content = await loadTemplate(
+    `${options.lang}/codeql/codeql-config.yml.ejs`,
+    { name: options.projectName },
+  );
+  return { path: '.github/codeql/codeql-config.yml', content };
+}
+
+export async function generateDependabot(
+  options: InitOptions,
+): Promise<GeneratedFile> {
+  const content = await loadTemplate('common/dependabot.yml.ejs', {
+    lang: options.lang,
+  });
+  return { path: '.github/dependabot.yml', content };
+}
+
+export async function generateReleaseConfig(): Promise<GeneratedFile> {
+  const content = await loadTemplate('common/release.yml.ejs', {});
+  return { path: '.github/release.yml', content };
+}
+
+export class FileWriteError extends Error {
+  constructor(
+    message: string,
+    public readonly targetPath: string,
+    public readonly cause?: Error,
+  ) {
+    super(message);
+    this.name = 'FileWriteError';
+  }
+}
+
+export async function writeGeneratedFiles(
+  targetDir: string,
+  files: GeneratedFile[],
+): Promise<void> {
+  try {
+    await fs.mkdir(targetDir, { recursive: true });
+  } catch (error) {
+    const fsError = error as NodeJS.ErrnoException;
+    throw new FileWriteError(
+      `Failed to create target directory "${targetDir}": ${fsError.message}`,
+      targetDir,
+      fsError,
+    );
+  }
+
+  for (const file of files) {
+    const filePath = path.join(targetDir, file.path);
+    const fileDir = path.dirname(filePath);
+
+    try {
+      if (fileDir !== targetDir) {
+        await fs.mkdir(fileDir, { recursive: true });
+      }
+      await fs.writeFile(filePath, file.content, 'utf-8');
+    } catch (error) {
+      const fsError = error as NodeJS.ErrnoException;
+      throw new FileWriteError(
+        `Failed to write file "${file.path}" in "${targetDir}": ${fsError.message}`,
+        filePath,
+        fsError,
+      );
+    }
+  }
+}
+
+export class ProjectNameError extends Error {
+  constructor(
+    message: string,
+    public readonly projectName: string,
+  ) {
+    super(message);
+    this.name = 'ProjectNameError';
+  }
+}
+
+const VALID_PROJECT_NAME_REGEX = /^(@[\w-]+\/)?[\w][\w.-]*[\w]$|^[\w]$/;
+
+export function validateProjectName(projectName: string): void {
+  if (!projectName || projectName.trim() === '') {
+    throw new ProjectNameError('Project name cannot be empty', projectName);
+  }
+
+  const nameWithoutScope = projectName.replace(/^@[\w-]+\//, '');
+  if (nameWithoutScope.includes('/') || nameWithoutScope.includes('\\')) {
+    throw new ProjectNameError(
+      `Project name "${projectName}" contains invalid path separators`,
+      projectName,
+    );
+  }
+
+  if (nameWithoutScope.startsWith('.') || nameWithoutScope.endsWith('.')) {
+    throw new ProjectNameError(
+      `Project name "${projectName}" cannot start or end with a dot`,
+      projectName,
+    );
+  }
+
+  if (!VALID_PROJECT_NAME_REGEX.test(projectName)) {
+    throw new ProjectNameError(
+      `Project name "${projectName}" contains invalid characters. Use only letters, numbers, hyphens, underscores, and dots.`,
+      projectName,
+    );
+  }
+}
+
+export async function generateProject(options: InitOptions): Promise<void> {
+  validateProjectName(options.projectName);
+
+  const outputDir = options.targetDir ?? options.projectName;
+  const actionVersions = await getLatestActionVersions();
+
+  const files: GeneratedFile[] = await Promise.all([
+    generatePackageJson(options),
+    generateTsconfig(options),
+    generateEntryPoint(options),
+    generateTagprConfig(options),
+    generateTagprWorkflow(options, actionVersions),
+    generateCiWorkflow(options, actionVersions),
+    generateCodeqlWorkflow(options, actionVersions),
+    generateCodeqlConfig(options),
+    generateDependabot(options),
+    generateReleaseConfig(),
+  ]);
+
+  try {
+    await writeGeneratedFiles(outputDir, files);
+  } catch (error) {
+    if (error instanceof FileWriteError) {
+      throw error;
+    }
+    throw new FileWriteError(
+      `Failed to generate project "${options.projectName}": ${error instanceof Error ? error.message : String(error)}`,
+      outputDir,
+      error instanceof Error ? error : undefined,
+    );
+  }
+}

package/src/templates/common/dependabot.yml.ejs

@@ -0,0 +1,12 @@
+version: 2
+updates:
+<% if (lang === 'typescript') { -%>
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+<% } -%>
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

package/src/templates/common/release.yml.ejs

@@ -0,0 +1,4 @@
+changelog:
+  exclude:
+    labels:
+      - tagpr