@linter-spec/cli 1.0.0

package/dist/lints/stylelint/do-stylelint.js

@@ -0,0 +1,15 @@
+import stylelint from 'stylelint';
+import { STYLELINT_FILE_EXT, STYLELINT_IGNORE_PATTERN } from '../../utils/constants.js';
+import { resolveScanFiles } from '../resolve-files.js';
+import { formatStylelintResults } from './format-results.js';
+import { getStylelintConfig } from './get-config.js';
+export async function doStylelint(options) {
+    const files = await resolveScanFiles(options, STYLELINT_FILE_EXT, STYLELINT_IGNORE_PATTERN);
+    if (files.length === 0)
+        return [];
+    const data = await stylelint.lint({
+        ...getStylelintConfig(options, options.pkg, options.config),
+        files,
+    });
+    return formatStylelintResults(data.results, options.quiet);
+}

package/dist/lints/stylelint/format-results.d.ts

@@ -0,0 +1,6 @@
+import type { LintResult } from 'stylelint';
+import type { ScanResult } from '../../types.js';
+/**
+ * Normalise Stylelint results into the shared `ScanResult` shape.
+ */
+export declare function formatStylelintResults(results: LintResult[], quiet: boolean | undefined): ScanResult[];

package/dist/lints/stylelint/format-results.js

@@ -0,0 +1,39 @@
+import { getStylelintRuleDocUrl } from './get-doc-url.js';
+/**
+ * Normalise Stylelint results into the shared `ScanResult` shape.
+ */
+export function formatStylelintResults(results, quiet) {
+    return results.map(({ source, warnings }) => {
+        let errorCount = 0;
+        let warningCount = 0;
+        const messages = warnings
+            .filter((item) => !quiet || item.severity === 'error')
+            .map((item) => {
+            const { line = 0, column = 0, rule, severity, text } = item;
+            if (severity === 'error') {
+                errorCount++;
+            }
+            else {
+                warningCount++;
+            }
+            return {
+                line,
+                column,
+                rule: rule ?? null,
+                url: getStylelintRuleDocUrl(rule),
+                message: text
+                    .replace(/([^ ])\.$/u, '$1')
+                    .replace(rule ? new RegExp(`\\(${rule}\\)`) : '', ''),
+                errored: severity === 'error',
+            };
+        });
+        return {
+            filePath: source ?? '',
+            messages,
+            errorCount,
+            warningCount,
+            fixableErrorCount: 0,
+            fixableWarningCount: 0,
+        };
+    });
+}

package/dist/lints/stylelint/get-config.d.ts

@@ -0,0 +1,7 @@
+import type { LinterOptions } from 'stylelint';
+import type { Config, PKG, ScanOptions } from '../../types.js';
+/**
+ * Build the Stylelint options. Uses the shared config unless the project
+ * provides its own.
+ */
+export declare function getStylelintConfig(opts: ScanOptions, pkg: PKG, config: Config): Partial<LinterOptions>;

package/dist/lints/stylelint/get-config.js

@@ -0,0 +1,33 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'fs-extra';
+import fg from 'fast-glob';
+import { STYLELINT_IGNORE_PATTERN } from '../../utils/constants.js';
+// Absolute path so Stylelint can resolve `extends` regardless of the project cwd.
+const stylelintConfigPath = fileURLToPath(import.meta.resolve('@linter-spec/stylelint-config'));
+/**
+ * Build the Stylelint options. Uses the shared config unless the project
+ * provides its own.
+ */
+export function getStylelintConfig(opts, pkg, config) {
+    const { cwd, fix } = opts;
+    const lintConfig = {
+        fix: Boolean(fix),
+        allowEmptyInput: true,
+    };
+    if (config.stylelintOptions) {
+        Object.assign(lintConfig, config.stylelintOptions);
+        return lintConfig;
+    }
+    const userConfig = fg.sync('.stylelintrc?(.@(js|cjs|mjs|yaml|yml|json))', { cwd, dot: true }).length > 0 ||
+        fg.sync('stylelint.config.@(js|mjs|cjs)', { cwd, dot: true }).length > 0 ||
+        Boolean(pkg.stylelint);
+    if (!userConfig) {
+        lintConfig.config = { extends: [stylelintConfigPath] };
+    }
+    const ignoreFilePath = path.resolve(cwd, '.stylelintignore');
+    if (!fs.existsSync(ignoreFilePath)) {
+        lintConfig.ignorePattern = STYLELINT_IGNORE_PATTERN;
+    }
+    return lintConfig;
+}

package/dist/lints/stylelint/get-doc-url.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Resolve the documentation URL for a Stylelint rule.
+ */
+export declare function getStylelintRuleDocUrl(rule: string | undefined): string;

package/dist/lints/stylelint/get-doc-url.js

@@ -0,0 +1,18 @@
+/**
+ * Resolve the documentation URL for a Stylelint rule.
+ */
+export function getStylelintRuleDocUrl(rule) {
+    if (!rule)
+        return '';
+    const scss = rule.match(/^scss\/(\S+)$/);
+    if (scss) {
+        return `https://github.com/stylelint-scss/stylelint-scss/tree/master/src/rules/${scss[1]}`;
+    }
+    const stylistic = rule.match(/^@stylistic\/(\S+)$/);
+    if (stylistic) {
+        return `https://github.com/stylelint-stylistic/stylelint-stylistic/blob/main/lib/rules/${stylistic[1]}/README.md`;
+    }
+    if (rule !== 'CssSyntaxError')
+        return `https://stylelint.io/user-guide/rules/${rule}`;
+    return '';
+}

package/dist/lints/stylelint/index.d.ts

@@ -0,0 +1,4 @@
+export * from './get-config.js';
+export * from './get-doc-url.js';
+export * from './format-results.js';
+export * from './do-stylelint.js';

package/dist/lints/stylelint/index.js

@@ -0,0 +1,4 @@
+export * from './get-config.js';
+export * from './get-doc-url.js';
+export * from './format-results.js';
+export * from './do-stylelint.js';

package/dist/types.d.ts

@@ -0,0 +1,85 @@
+import type { ESLint } from 'eslint';
+import type stylelint from 'stylelint';
+import type markdownlint from 'markdownlint';
+export interface PKG {
+    eslintConfig?: unknown;
+    eslintIgnore?: string[];
+    stylelint?: unknown;
+    husky?: Record<string, unknown>;
+    scripts?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+export interface Config {
+    /** Enable ESLint (default true). */
+    enableESLint?: boolean;
+    /** Enable Stylelint (default true). */
+    enableStylelint?: boolean;
+    /** Enable markdownlint (default true). */
+    enableMarkdownlint?: boolean;
+    /** Enable Prettier (default true). */
+    enablePrettier?: boolean;
+    /** Override ESLint options. */
+    eslintOptions?: ESLint.Options;
+    /** Override Stylelint options. */
+    stylelintOptions?: Partial<stylelint.LinterOptions>;
+    /** Override markdownlint options. */
+    markdownlintOptions?: markdownlint.Options;
+}
+export interface ScanOptions {
+    /** Project root the lint runs in. */
+    cwd: string;
+    /** Directory to scan. */
+    include: string;
+    /** Explicit file list to scan (overrides `include`). */
+    files?: string[];
+    /** Only report errors. */
+    quiet?: boolean;
+    /** Honour ESLint ignore files / rules (maps to `--no-ignore`). */
+    ignore?: boolean;
+    /** Auto-fix. */
+    fix?: boolean;
+    /** Write a JSON report file. */
+    outputReport?: boolean;
+    /** Inline config, takes precedence over `linter-spec.config.*`. */
+    config?: Config;
+}
+export interface ScanMessage {
+    line: number;
+    column: number;
+    rule: string | null;
+    url: string;
+    message: string;
+    errored: boolean;
+}
+export interface ScanResult {
+    filePath: string;
+    errorCount: number;
+    warningCount: number;
+    fixableErrorCount: number;
+    fixableWarningCount: number;
+    messages: ScanMessage[];
+}
+export interface ScanReport {
+    results: ScanResult[];
+    errorCount: number;
+    warningCount: number;
+    runErrors: Error[];
+}
+export interface InitOptions {
+    cwd: string;
+    /** Check for and self-update the CLI before initialising. */
+    checkVersionUpdate: boolean;
+    /** Auto-rewrite conflicting lint config without prompting. */
+    rewriteConfig?: boolean;
+    /** ESLint project type (see `PROJECT_TYPES`). */
+    eslintType?: string;
+    enableESLint?: boolean;
+    enableStylelint?: boolean;
+    enableMarkdownlint?: boolean;
+    enablePrettier?: boolean;
+    /** Skip the post-init dependency install. */
+    disableNpmInstall?: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/conflict-resolve.d.ts

@@ -0,0 +1,2 @@
+import type { PKG } from '../types.js';
+export default function conflictResolve(cwd: string, rewriteConfig?: boolean): Promise<PKG>;

package/dist/utils/conflict-resolve.js

@@ -0,0 +1,103 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'fs-extra';
+import fg from 'fast-glob';
+import { confirm } from '@inquirer/prompts';
+import log from './log.js';
+import { messages } from './messages.js';
+import { CliAbortError } from './errors.js';
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+// Remove these exact dependencies (they conflict or are superseded).
+const packageNamesToRemove = [
+    '@babel/eslint-parser',
+    '@commitlint/cli',
+    '@iceworks/spec',
+    'babel-eslint',
+    'eslint',
+    'husky',
+    'markdownlint',
+    'prettier',
+    'stylelint',
+    'tslint',
+];
+// Remove dependencies starting with these prefixes.
+const packagePrefixesToRemove = [
+    '@commitlint/',
+    '@typescript-eslint/',
+    'eslint-',
+    'stylelint-',
+    'markdownlint-',
+    'commitlint-',
+];
+/** Old, now-unused lint config files to delete. */
+const checkUselessConfig = (cwd) => []
+    .concat(fg.sync('.eslintrc?(.@(yaml|yml|json))', { cwd, dot: true }))
+    .concat(fg.sync('.stylelintrc?(.@(yaml|yml|json))', { cwd, dot: true }))
+    // Old markdownlint config slots we no longer write — all superseded by the
+    // single `.markdownlint-cli2.cjs` we now emit:
+    //   - `.markdownlint.{json,jsonc,yaml,yml}` / `.markdownlintrc`: legacy
+    //     ruleset slots.
+    //   - `.markdownlint.cjs`: the ruleset slot an earlier version of this CLI
+    //     wrote; cli2 reads it but at lower precedence than `.markdownlint-cli2.cjs`,
+    //     so leaving it behind would only confuse readers.
+    //   - `.markdownlintignore`: never read by cli2 or the VS Code extension
+    //     (only by the legacy `markdownlint-cli`); ignores now live in the cli2
+    //     config's `ignores` field.
+    .concat(fg.sync('.markdownlint@(rc|.@(json|jsonc|yaml|yml|cjs))', { cwd, dot: true }))
+    .concat(fg.sync('.markdownlintignore', { cwd, dot: true }))
+    .concat(fg.sync('.prettierrc?(.@(cjs|config.js|config.cjs|yaml|yml|json|json5|toml))', {
+    cwd,
+    dot: true,
+}))
+    .concat(fg.sync('tslint.@(yaml|yml|json)', { cwd, dot: true }))
+    .concat(fg.sync('.kylerc?(.@(yaml|yml|json))', { cwd, dot: true }));
+/** Config files we are about to (over)write that already exist. */
+const checkReWriteConfig = (cwd) => fg
+    .sync('**/*.ejs', { cwd: path.resolve(dirname, '../config'), dot: true })
+    .map((name) => name.replace(/^_/, '.').replace(/\.ejs$/, ''))
+    .filter((filename) => fs.existsSync(path.resolve(cwd, filename)));
+export default async function conflictResolve(cwd, rewriteConfig) {
+    const pkgPath = path.resolve(cwd, 'package.json');
+    const pkg = fs.readJSONSync(pkgPath);
+    const dependencies = [].concat(Object.keys(pkg.dependencies || {}), Object.keys(pkg.devDependencies || {}));
+    const willRemovePackage = dependencies.filter((name) => packageNamesToRemove.includes(name) ||
+        packagePrefixesToRemove.some((prefix) => name.startsWith(prefix)));
+    const uselessConfig = checkUselessConfig(cwd);
+    const reWriteConfig = checkReWriteConfig(cwd);
+    const willChangeCount = willRemovePackage.length + uselessConfig.length + reWriteConfig.length;
+    if (willChangeCount > 0) {
+        log.warn(messages.conflictDetected);
+        if (willRemovePackage.length > 0) {
+            log.warn(messages.conflictRemoveDeps);
+            log.warn(JSON.stringify(willRemovePackage, null, 2));
+        }
+        if (uselessConfig.length > 0) {
+            log.warn(messages.conflictRemoveConfig);
+            log.warn(JSON.stringify(uselessConfig, null, 2));
+        }
+        if (reWriteConfig.length > 0) {
+            log.warn(messages.conflictRewriteConfig);
+            log.warn(JSON.stringify(reWriteConfig, null, 2));
+        }
+        if (typeof rewriteConfig === 'undefined') {
+            const isOverWrite = await confirm({ message: messages.conflictConfirm });
+            if (!isOverWrite)
+                throw new CliAbortError();
+        }
+        else if (!rewriteConfig) {
+            throw new CliAbortError();
+        }
+    }
+    for (const name of uselessConfig) {
+        fs.removeSync(path.resolve(cwd, name));
+    }
+    delete pkg.eslintConfig;
+    delete pkg.eslintIgnore;
+    delete pkg.stylelint;
+    for (const name of willRemovePackage) {
+        delete (pkg.dependencies || {})[name];
+        delete (pkg.devDependencies || {})[name];
+    }
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2), 'utf8');
+    return pkg;
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,43 @@
+export declare const UNICODE: {
+    readonly success: "✔";
+    readonly failure: "✖";
+};
+/** npm package name, e.g. `@linter-spec/cli` (used for install / update). */
+export declare const PKG_NAME: string;
+/** Package version. */
+export declare const PKG_VERSION: string;
+/** The user-facing command name / config-file prefix, e.g. `linter-spec`. */
+export declare const CLI_NAME = "linter-spec";
+/**
+ * Project types — values map 1:1 to `@linter-spec/eslint-config` export
+ * subpaths (`index` → the package root export).
+ */
+export declare const PROJECT_TYPES: Array<{
+    name: string;
+    value: string;
+}>;
+/** ESLint scan file extensions. */
+export declare const ESLINT_FILE_EXT: string[];
+/**
+ * ESLint flat-config global ignore globs.
+ * (ESLint 9 dropped `.eslintignore`; ignores now live in the flat config.)
+ */
+export declare const ESLINT_IGNORE_GLOBS: string[];
+/** Stylelint scan file extensions. */
+export declare const STYLELINT_FILE_EXT: string[];
+/** Stylelint ignore patterns. */
+export declare const STYLELINT_IGNORE_PATTERN: string[];
+/** markdownlint scan file extensions. */
+export declare const MARKDOWN_LINT_FILE_EXT: string[];
+/**
+ * markdownlint ignore patterns — micromatch globs.
+ *
+ * Used as fast-glob's `ignore` in `linter-spec scan/fix`, AND emitted into the
+ * generated `.markdownlint-cli2.cjs`'s `ignores` field which markdownlint-cli2
+ * matches with micromatch. Globs that work in both: `**\/<dir>/**`.
+ */
+export declare const MARKDOWN_LINT_IGNORE_PATTERN: string[];
+/** Prettier scan file extensions (union of the lint extensions). */
+export declare const PRETTIER_FILE_EXT: string[];
+/** Prettier ignore patterns. */
+export declare const PRETTIER_IGNORE_PATTERN: string[];

package/dist/utils/constants.js

@@ -0,0 +1,91 @@
+// dist/utils/constants.js (and src/utils/constants.ts) are both two levels deep,
+// so the relative path to the package manifest is identical at build & runtime.
+import pkg from '../../package.json' with { type: 'json' };
+export const UNICODE = {
+    success: '✔', // ✔
+    failure: '✖', // ✖
+};
+/** npm package name, e.g. `@linter-spec/cli` (used for install / update). */
+export const PKG_NAME = pkg.name;
+/** Package version. */
+export const PKG_VERSION = pkg.version;
+/** The user-facing command name / config-file prefix, e.g. `linter-spec`. */
+export const CLI_NAME = 'linter-spec';
+/**
+ * Project types — values map 1:1 to `@linter-spec/eslint-config` export
+ * subpaths (`index` → the package root export).
+ */
+export const PROJECT_TYPES = [
+    { name: '未使用 React、Vue、Node.js 的项目（JavaScript）', value: 'index' },
+    { name: '未使用 React、Vue、Node.js 的项目（TypeScript）', value: 'typescript' },
+    { name: 'React 项目（JavaScript）', value: 'react' },
+    { name: 'React 项目（TypeScript）', value: 'typescript/react' },
+    { name: 'Vue 项目（JavaScript）', value: 'vue' },
+    { name: 'Vue 项目（TypeScript）', value: 'typescript/vue' },
+    { name: 'Node.js 项目（JavaScript）', value: 'node' },
+    { name: 'Node.js 项目（TypeScript）', value: 'typescript/node' },
+    { name: '使用 ES5 及之前版本 JavaScript 的老项目', value: 'es5' },
+];
+/** ESLint scan file extensions. */
+export const ESLINT_FILE_EXT = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.mjs', '.cjs'];
+/**
+ * ESLint flat-config global ignore globs.
+ * (ESLint 9 dropped `.eslintignore`; ignores now live in the flat config.)
+ */
+export const ESLINT_IGNORE_GLOBS = [
+    '**/node_modules/**',
+    '**/build/**',
+    '**/dist/**',
+    '**/coverage/**',
+    '**/es/**',
+    '**/lib/**',
+    '**/*.min.js',
+    '**/*-min.js',
+    '**/*.bundle.js',
+];
+/** Stylelint scan file extensions. */
+export const STYLELINT_FILE_EXT = ['.css', '.scss', '.less', '.acss'];
+/** Stylelint ignore patterns. */
+export const STYLELINT_IGNORE_PATTERN = [
+    '**/node_modules/**',
+    '**/build/**',
+    '**/dist/**',
+    '**/coverage/**',
+    '**/es/**',
+    '**/lib/**',
+    '**/*.min.css',
+    '**/*-min.css',
+    '**/*.bundle.css',
+];
+/** markdownlint scan file extensions. */
+export const MARKDOWN_LINT_FILE_EXT = ['.md'];
+/**
+ * markdownlint ignore patterns — micromatch globs.
+ *
+ * Used as fast-glob's `ignore` in `linter-spec scan/fix`, AND emitted into the
+ * generated `.markdownlint-cli2.cjs`'s `ignores` field which markdownlint-cli2
+ * matches with micromatch. Globs that work in both: `**\/<dir>/**`.
+ */
+export const MARKDOWN_LINT_IGNORE_PATTERN = [
+    '**/node_modules/**',
+    '**/build/**',
+    '**/dist/**',
+    '**/coverage/**',
+    '**/es/**',
+    '**/lib/**',
+];
+/** Prettier scan file extensions (union of the lint extensions). */
+export const PRETTIER_FILE_EXT = [
+    ...STYLELINT_FILE_EXT,
+    ...ESLINT_FILE_EXT,
+    ...MARKDOWN_LINT_FILE_EXT,
+];
+/** Prettier ignore patterns. */
+export const PRETTIER_IGNORE_PATTERN = [
+    'node_modules/**/*',
+    'build/**/*',
+    'dist/**/*',
+    'lib/**/*',
+    'es/**/*',
+    'coverage/**/*',
+];

package/dist/utils/errors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Thrown by library-level code (e.g. conflict resolution) when the user declines
+ * to continue. The CLI command layer catches it and exits cleanly, instead of the
+ * library calling `process.exit` directly — which would silently kill any program
+ * that consumes the Node API.
+ */
+export declare class CliAbortError extends Error {
+    constructor(message?: string);
+}

package/dist/utils/errors.js

@@ -0,0 +1,12 @@
+/**
+ * Thrown by library-level code (e.g. conflict resolution) when the user declines
+ * to continue. The CLI command layer catches it and exits cleanly, instead of the
+ * library calling `process.exit` directly — which would silently kill any program
+ * that consumes the Node API.
+ */
+export class CliAbortError extends Error {
+    constructor(message = 'Operation aborted by user') {
+        super(message);
+        this.name = 'CliAbortError';
+    }
+}

package/dist/utils/generate-template.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Render the EJS config templates into `cwd`.
+ * @param cwd  target project root
+ * @param data template variables (the resolved `Config` plus `eslintType`)
+ * @param vscode only emit the `.vscode/*` templates
+ */
+export default function generateTemplate(cwd: string, data: Record<string, unknown>, vscode?: boolean): void;

package/dist/utils/generate-template.js

@@ -0,0 +1,67 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'fs-extra';
+import fg from 'fast-glob';
+import ejs from 'ejs';
+import { ESLINT_IGNORE_GLOBS, STYLELINT_FILE_EXT, STYLELINT_IGNORE_PATTERN, MARKDOWN_LINT_IGNORE_PATTERN, } from './constants.js';
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/**
+ * Deep-merge two parsed-JSON values: objects merge recursively, arrays are
+ * unioned (source first, deduped), and primitives take the source value.
+ * Replaces the single former `lodash.mergeWith` call site.
+ */
+const deepMerge = (target, source) => {
+    if (Array.isArray(target) && Array.isArray(source)) {
+        return [...new Set([...source, ...target])];
+    }
+    if (isObject(target) && isObject(source)) {
+        const out = { ...target };
+        for (const key of Object.keys(source)) {
+            out[key] = key in target ? deepMerge(target[key], source[key]) : source[key];
+        }
+        return out;
+    }
+    return source;
+};
+/**
+ * Merge a generated VS Code config into an existing one (arrays are unioned).
+ */
+const mergeVSCodeConfig = (filepath, content) => {
+    if (!fs.existsSync(filepath))
+        return content;
+    try {
+        const targetData = fs.readJSONSync(filepath);
+        const sourceData = JSON.parse(content);
+        return JSON.stringify(deepMerge(targetData, sourceData), null, 2);
+    }
+    catch {
+        return '';
+    }
+};
+/**
+ * Render the EJS config templates into `cwd`.
+ * @param cwd  target project root
+ * @param data template variables (the resolved `Config` plus `eslintType`)
+ * @param vscode only emit the `.vscode/*` templates
+ */
+export default function generateTemplate(cwd, data, vscode) {
+    const templatePath = path.resolve(dirname, '../config');
+    const templates = fg.sync(`${vscode ? '_vscode' : '**'}/*.ejs`, { cwd: templatePath, dot: true });
+    for (const name of templates) {
+        const filepath = path.resolve(cwd, name.replace(/\.ejs$/, '').replace(/^_/, '.'));
+        let content = ejs.render(fs.readFileSync(path.resolve(templatePath, name), 'utf8'), {
+            eslintIgnores: ESLINT_IGNORE_GLOBS,
+            stylelintExt: STYLELINT_FILE_EXT,
+            stylelintIgnores: STYLELINT_IGNORE_PATTERN,
+            markdownLintIgnores: MARKDOWN_LINT_IGNORE_PATTERN,
+            ...data,
+        });
+        if (/^_vscode/.test(name)) {
+            content = mergeVSCodeConfig(filepath, content);
+        }
+        if (!content.trim())
+            continue;
+        fs.outputFileSync(filepath, content, 'utf8');
+    }
+}

package/dist/utils/git.d.ts

@@ -0,0 +1,9 @@
+import { type Options } from 'execa';
+/**
+ * Files changed in this commit (staged, added/copied/modified/renamed).
+ */
+export declare const getCommitFiles: (options?: Options) => Promise<string[]>;
+/**
+ * Files modified in the working tree but not yet staged.
+ */
+export declare const getAmendFiles: (options?: Options) => Promise<string>;

package/dist/utils/git.js

@@ -0,0 +1,28 @@
+import { execa } from 'execa';
+/**
+ * Files changed in this commit (staged, added/copied/modified/renamed).
+ */
+export const getCommitFiles = async (options = {}) => {
+    try {
+        const { stdout } = await execa('git', ['diff', '--staged', '--diff-filter=ACMR', '--name-only', '--ignore-submodules'], { ...options, cwd: options.cwd || process.cwd() });
+        return typeof stdout === 'string' && stdout ? stdout.split(/\s/).filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+};
+/**
+ * Files modified in the working tree but not yet staged.
+ */
+export const getAmendFiles = async (options = {}) => {
+    try {
+        const { stdout } = await execa('git', ['diff', '--name-only'], {
+            ...options,
+            cwd: options.cwd || process.cwd(),
+        });
+        return typeof stdout === 'string' ? stdout : '';
+    }
+    catch {
+        return '';
+    }
+};

package/dist/utils/log.d.ts

@@ -0,0 +1,8 @@
+declare const log: {
+    success(text: string): void;
+    info(text: string): void;
+    warn(text: string): void;
+    error(text: string | Error): void;
+    result(text: string, pass: boolean): void;
+};
+export default log;

package/dist/utils/log.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { CLI_NAME, UNICODE } from './constants.js';
+const { green, blue, yellow, red } = chalk;
+const log = {
+    success(text) {
+        console.log(green(text));
+    },
+    info(text) {
+        console.info(blue(text));
+    },
+    warn(text) {
+        console.info(yellow(text));
+    },
+    error(text) {
+        // Print the full stack when given an Error (the stack string already
+        // includes the message); fall back to the message / raw string otherwise.
+        console.error(red(text instanceof Error ? (text.stack ?? text.message) : text));
+    },
+    result(text, pass) {
+        console.info(blue(`[${CLI_NAME}] ${text}`), pass ? green(UNICODE.success) : red(UNICODE.failure));
+    },
+};
+export default log;