or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

build-management.mdcli-commands.mdindex.mdinitialization.mdutilities.md
tile.json

initialization.mddocs/

Project Initialization

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);
}