tessl/npm-gts

Google TypeScript Style guide, formatter, linter, and code fixer with zero configuration required

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Project Initialization

Name: tessl/npm-gts
Author: tessl

Project setup functionality for adding gts configuration, scripts, and dependencies to TypeScript projects.

Capabilities

Main Initialization Function

Complete project initialization including scripts, dependencies, and configuration files.

/**
 * Initialize gts in a TypeScript project
 * @param options - Configuration options for initialization
 * @returns Promise resolving to true on success
 */
function init(options: Options): Promise<boolean>;

Usage Example:

import { init } from "gts/build/src/init";
import { Options } from "gts/build/src/cli";

const options: Options = {
  dryRun: false,           // Set to true to preview changes
  gtsRootDir: "/path/to/gts/installation",
  targetRootDir: process.cwd(),
  yes: true,               // Auto-confirm all prompts
  no: false,
  logger: console,
  yarn: false              // Use npm instead of yarn
};

const success = await init(options);

Script Management

Add npm scripts to package.json for common development tasks.

/**
 * Add gts-related npm scripts to package.json
 * @param packageJson - Parsed package.json object
 * @param options - Configuration options
 * @returns Promise resolving to true if scripts were added/modified
 */
function addScripts(
  packageJson: PackageJSON,
  options: Options
): Promise<boolean>;

Scripts added:

lint: "gts lint" - Run linting
clean: "gts clean" - Clean build output
compile: "tsc" - Compile TypeScript
fix: "gts fix" - Fix linting and formatting issues
prepare: "npm run compile" (or yarn run compile)
pretest: "npm run compile" - Compile before tests
posttest: "npm run lint" - Lint after tests

Usage Example:

import { addScripts } from "gts/build/src/init";
import { readJsonp } from "gts/build/src/util";

const packageJson = await readJsonp("./package.json");
const scriptsAdded = await addScripts(packageJson, options);

if (scriptsAdded) {
  console.log("Scripts were added or modified");
}

Dependency Management

Add required development dependencies to package.json.

/**
 * Add gts development dependencies to package.json
 * @param packageJson - Parsed package.json object
 * @param options - Configuration options
 * @returns Promise resolving to true if dependencies were added/modified
 */
function addDependencies(
  packageJson: PackageJSON,
  options: Options
): Promise<boolean>;

Dependencies added:

gts: Current gts version (e.g., "^6.0.2")
typescript: TypeScript version from gts dependencies
@types/node: Node.js type definitions

Usage Example:

import { addDependencies } from "gts/build/src/init";

const depsAdded = await addDependencies(packageJson, options);

Template Installation

Install default TypeScript template files in the src/ directory.

/**
 * Install default TypeScript template files
 * @param options - Configuration options
 * @returns Promise resolving to true if template was installed
 */
function installDefaultTemplate(options: Options): Promise<boolean>;

The template includes:

src/index.ts: Example TypeScript file with intentional style issues
Demonstrates common formatting problems that gts can fix
Only installs if no .ts files exist in the target src/ directory

Usage Example:

import { installDefaultTemplate } from "gts/build/src/init";

const templateInstalled = await installDefaultTemplate(options);

Configuration Constants

Pre-defined configuration objects for ESLint setup.

const ESLINT_CONFIG: {
  extends: string;
};

const ESLINT_IGNORE: string;

Values:

ESLINT_CONFIG: { extends: './node_modules/gts/' }
ESLINT_IGNORE: "build/\n"

Configuration File Generation

The initialization process creates several configuration files:

.eslintrc.json

{
  "extends": "./node_modules/gts/"
}

.eslintignore

build/

tsconfig.json

{
  "extends": "./node_modules/gts/tsconfig-google.json",
  "compilerOptions": {
    "rootDir": ".",
    "outDir": "build"
  },
  "include": [
    "src/**/*.ts",
    "test/**/*.ts"
  ]
}

.prettierrc.js

module.exports = {
  ...require('gts/.prettierrc.json')
}

.editorconfig

root = true

[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
insert_final_newline = true

Interactive Prompts

When options.yes and options.no are both false, the initialization process prompts for user confirmation:

Overwrite existing scripts in package.json
Overwrite existing dependencies
Overwrite existing configuration files
Generate package.json if it doesn't exist

Package Manager Integration

Automatically detects and uses the appropriate package manager:

Runs npm install --ignore-scripts after setup (or yarn install --ignore-scripts)
Uses yarn if yarn.lock exists and no package-lock.json
Uses npm if package-lock.json exists
Can be overridden with options.yarn

Error Handling

The initialization process handles various error conditions:

Missing package.json (offers to generate one)
Existing files and scripts (prompts for overwrite)
File system errors during template installation
Network errors during dependency installation

Example with error handling:

import { init } from "gts/build/src/init";

try {
  const success = await init(options);
  if (!success) {
    console.error("Initialization was cancelled or failed");
  }
} catch (error) {
  console.error("System error during initialization:", error.message);
}