@fuzdev/gro 0.192.0

package/dist/task.d.ts

@@ -0,0 +1,98 @@
+import type { Args } from '@fuzdev/fuz_util/args.js';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+import type { Result } from '@fuzdev/fuz_util/result.js';
+import type { Timings } from '@fuzdev/fuz_util/timings.js';
+import type { z } from 'zod';
+import type { GroConfig } from './gro_config.ts';
+import type { ParsedSvelteConfig } from './svelte_config.ts';
+import { type InputPath, type ResolvedInputFile, type ResolvedInputPath } from './input_path.ts';
+import { type LoadModulesFailure, type ModuleMeta } from './modules.ts';
+import type { Filer } from './filer.ts';
+export interface Task<TArgs = Args, TArgsSchema extends z.ZodType<Args, Args> = z.ZodType<Args, Args>, // TODO improve type? separate input/output?
+TReturn = unknown> {
+    run: (ctx: TaskContext<TArgs>) => TReturn | Promise<TReturn>;
+    summary?: string;
+    Args?: TArgsSchema;
+}
+export interface TaskContext<TArgs = object> {
+    args: TArgs;
+    config: GroConfig;
+    svelte_config: ParsedSvelteConfig;
+    filer: Filer;
+    log: Logger;
+    timings: Timings;
+    invoke_task: InvokeTask;
+}
+export type InvokeTask = (task_name: string, args?: Args, config?: GroConfig) => Promise<void>;
+export declare const TASK_FILE_SUFFIX_TS = ".task.ts";
+export declare const TASK_FILE_SUFFIX_JS = ".task.js";
+export declare const TASK_FILE_SUFFIXES: string[];
+export declare const is_task_path: (path: string) => boolean;
+export declare const to_task_name: (id: PathId, task_root_dir: PathId, input_path: InputPath, root_path: PathId) => string;
+/**
+ * This is used by tasks to signal a known failure.
+ * It's useful for cleaning up logging because
+ * we usually don't need their stack trace.
+ */
+export declare class TaskError extends Error {
+}
+/**
+ * This is used to tell Gro to exit silently, usually still with with a non-zero exit code.
+ * Using it means error logging is handled by the code that threw it.
+ */
+export declare class SilentError extends Error {
+}
+export interface FoundTask {
+    input_path: InputPath;
+    id: PathId;
+    task_root_dir: PathId;
+}
+export interface FoundTasks {
+    resolved_input_files: Array<ResolvedInputFile>;
+    resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+    resolved_input_paths: Array<ResolvedInputPath>;
+    input_paths: Array<InputPath>;
+    task_root_dirs: Array<PathId>;
+}
+export type FindTasksResult = Result<{
+    value: FoundTasks;
+}, FindModulesFailure>;
+export type FindModulesFailure = {
+    type: 'unmapped_input_paths';
+    unmapped_input_paths: Array<InputPath>;
+    resolved_input_paths: Array<ResolvedInputPath>;
+    input_paths: Array<InputPath>;
+    task_root_dirs: Array<PathId>;
+    reasons: Array<string>;
+} | {
+    type: 'input_directories_with_no_files';
+    input_directories_with_no_files: Array<InputPath>;
+    resolved_input_files: Array<ResolvedInputFile>;
+    resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+    resolved_input_paths: Array<ResolvedInputPath>;
+    input_paths: Array<InputPath>;
+    task_root_dirs: Array<PathId>;
+    reasons: Array<string>;
+};
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export declare const find_tasks: (input_paths: Array<InputPath>, task_root_dirs: Array<PathId>, config: GroConfig, timings?: Timings) => Promise<FindTasksResult>;
+export interface LoadedTasks {
+    modules: Array<TaskModuleMeta>;
+    found_tasks: FoundTasks;
+}
+export interface TaskModule {
+    task: Task;
+}
+export interface TaskModuleMeta extends ModuleMeta<TaskModule> {
+    name: string;
+}
+export type LoadTasksResult = Result<{
+    value: LoadedTasks;
+}, LoadTasksFailure>;
+export type LoadTasksFailure = LoadModulesFailure<TaskModuleMeta>;
+export declare const load_tasks: (found_tasks: FoundTasks, root_path?: PathId) => Promise<LoadTasksResult>;
+export declare const validate_task_module: (mod: Record<string, any>) => mod is TaskModule;
+//# sourceMappingURL=task.d.ts.map

package/dist/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/task.ts"],"names":[],"mappings":"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"}

package/dist/task.js

@@ -0,0 +1,109 @@
+import { fs_search } from '@fuzdev/fuz_util/fs.js';
+import { ensure_end, strip_end, strip_start } from '@fuzdev/fuz_util/string.js';
+import { isAbsolute, join, relative } from 'node:path';
+import { styleText as st } from 'node:util';
+import { resolve_input_files, resolve_input_paths, } from "./input_path.js";
+import { GRO_DIST_DIR, print_path } from "./paths.js";
+import { load_modules } from "./modules.js";
+export const TASK_FILE_SUFFIX_TS = '.task.ts';
+export const TASK_FILE_SUFFIX_JS = '.task.js';
+export const TASK_FILE_SUFFIXES = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS]; // TODO from `GroConfig`, but needs to be used everywhere the constants are
+export const is_task_path = (path) => path.endsWith(TASK_FILE_SUFFIX_TS) || path.endsWith(TASK_FILE_SUFFIX_JS);
+export const to_task_name = (id, task_root_dir, input_path, root_path) => {
+    let task_name = id.startsWith(task_root_dir)
+        ? strip_start(strip_start(id, task_root_dir), '/')
+        : id;
+    for (const suffix of TASK_FILE_SUFFIXES) {
+        task_name = strip_end(task_name, suffix);
+    }
+    if (ensure_end(task_root_dir, '/') === GRO_DIST_DIR) {
+        // TODO ideally it would display this in some contexts like the task progress logs,
+        // but not all, like printing the task list, UNLESS there's a local override
+        // return 'gro/' + task_name;
+        return task_name;
+    }
+    if (isAbsolute(input_path)) {
+        return relative(root_path, join(task_root_dir, task_name));
+    }
+    return task_name;
+};
+/**
+ * This is used by tasks to signal a known failure.
+ * It's useful for cleaning up logging because
+ * we usually don't need their stack trace.
+ */
+export class TaskError extends Error {
+}
+/**
+ * This is used to tell Gro to exit silently, usually still with with a non-zero exit code.
+ * Using it means error logging is handled by the code that threw it.
+ */
+export class SilentError extends Error {
+}
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export const find_tasks = async (input_paths, task_root_dirs, config, timings) => {
+    // Check which extension variation works - if it's a directory, prefer others first!
+    const timing_to_resolve_input_paths = timings?.start('resolve input paths');
+    const { resolved_input_paths, unmapped_input_paths } = await resolve_input_paths(input_paths, task_root_dirs, TASK_FILE_SUFFIXES);
+    timing_to_resolve_input_paths?.();
+    // Error if any input path could not be mapped.
+    if (unmapped_input_paths.length) {
+        return {
+            ok: false,
+            type: 'unmapped_input_paths',
+            unmapped_input_paths,
+            resolved_input_paths,
+            input_paths,
+            task_root_dirs,
+            reasons: unmapped_input_paths.map((input_path) => st('red', `Input path ${print_path(input_path)} cannot be mapped to a file or directory.`)),
+        };
+    }
+    // Find all of the files for any directories.
+    const timing_to_resolve_input_files = timings?.start('resolve input files');
+    const { resolved_input_files, resolved_input_files_by_root_dir, input_directories_with_no_files } = await resolve_input_files(resolved_input_paths, async (id) => await fs_search(id, {
+        filter: config.search_filters,
+        file_filter: (p) => TASK_FILE_SUFFIXES.some((s) => p.endsWith(s)),
+    }));
+    timing_to_resolve_input_files?.();
+    // Error if any input path has no files. (means we have an empty directory)
+    if (input_directories_with_no_files.length) {
+        return {
+            ok: false,
+            type: 'input_directories_with_no_files',
+            input_directories_with_no_files,
+            resolved_input_files,
+            resolved_input_files_by_root_dir,
+            resolved_input_paths,
+            input_paths,
+            task_root_dirs,
+            reasons: input_directories_with_no_files.map((input_path) => st('red', `Input directory contains no matching files: ${print_path(input_path)}`)),
+        };
+    }
+    return {
+        ok: true,
+        value: {
+            resolved_input_files,
+            resolved_input_files_by_root_dir,
+            resolved_input_paths,
+            input_paths,
+            task_root_dirs,
+        },
+    };
+};
+export const load_tasks = async (found_tasks, root_path = process.cwd()) => {
+    const loaded_modules = await load_modules(found_tasks.resolved_input_files, validate_task_module, (resolved_input_file, mod) => ({
+        id: resolved_input_file.id,
+        mod,
+        name: to_task_name(resolved_input_file.id, resolved_input_file.resolved_input_path.root_dir, resolved_input_file.resolved_input_path.input_path, root_path),
+    }));
+    if (!loaded_modules.ok) {
+        return loaded_modules;
+    }
+    return {
+        ok: true,
+        value: { modules: loaded_modules.modules, found_tasks },
+    };
+};
+export const validate_task_module = (mod) => !!mod.task && typeof mod.task.run === 'function';

package/dist/task_logging.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { LoadedTasks, TaskModuleMeta } from './task.ts';
+export declare const log_tasks: (log: Logger, loaded_tasks: LoadedTasks, log_intro?: boolean) => void;
+export declare const log_error_reasons: (log: Logger, reasons: Array<string>) => void;
+export declare const log_task_help: (log: Logger, meta: TaskModuleMeta) => void;
+//# sourceMappingURL=task_logging.d.ts.map

package/dist/task_logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task_logging.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/task_logging.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAKpD,OAAO,KAAK,EAAC,WAAW,EAAE,cAAc,EAAC,MAAM,WAAW,CAAC;AAG3D,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,cAAc,WAAW,EAAE,mBAAgB,KAAG,IAkCpF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,KAAK,MAAM,EAAE,SAAS,KAAK,CAAC,MAAM,CAAC,KAAG,IAIvE,CAAC;AAIF,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,MAAM,cAAc,KAAG,IAkCjE,CAAC"}

package/dist/task_logging.js

@@ -0,0 +1,201 @@
+import { print_value } from '@fuzdev/fuz_util/print.js';
+import { plural } from '@fuzdev/fuz_util/string.js';
+import { styleText as st } from 'node:util';
+import { z } from 'zod';
+import { print_path } from "./paths.js";
+export const log_tasks = (log, loaded_tasks, log_intro = true) => {
+    const { modules, found_tasks } = loaded_tasks;
+    const { resolved_input_files_by_root_dir } = found_tasks;
+    const logged = [];
+    if (log_intro) {
+        logged.unshift(`\n\n${st('gray', 'Run a task:')} gro [name]`, `\n${st('gray', 'View help:')}  gro [name] --help`);
+    }
+    for (const [root_dir, resolved_input_files] of resolved_input_files_by_root_dir) {
+        const dir_label = print_path(root_dir);
+        if (!resolved_input_files.length) {
+            log.info(`No tasks found in ${dir_label}.`);
+            continue;
+        }
+        logged.push(`${log_intro ? '\n\n' : ''}${resolved_input_files.length} task${plural(resolved_input_files.length)} in ${dir_label}:\n`);
+        const longest_task_name = to_max_length(modules, (m) => m.name);
+        for (const resolved_input_file of resolved_input_files) {
+            const meta = modules.find((m) => m.id === resolved_input_file.id);
+            logged.push('\n' + st('cyan', meta.name.padEnd(longest_task_name)), '  ', meta.mod.task.summary ?? '');
+        }
+    }
+    log[log_intro ? 'info' : 'raw'](logged.join('') + '\n');
+};
+export const log_error_reasons = (log, reasons) => {
+    for (const reason of reasons) {
+        log.error(st('red', reason));
+    }
+};
+const ARGS_PROPERTY_NAME = '[...args]';
+export const log_task_help = (log, meta) => {
+    const { name, mod: { task }, } = meta;
+    const logged = [];
+    logged.push(st('cyan', name), 'help', st('cyan', `\n\ngro ${name}`) + `: ${task.summary ?? '(no summary available)'}\n`);
+    if (task.Args) {
+        const properties = to_arg_properties(task.Args, meta, log);
+        // TODO hacky padding for some quick and dirty tables
+        const longest_task_name = Math.max(ARGS_PROPERTY_NAME.length, to_max_length(properties, (p) => p.name));
+        const longest_type = to_max_length(properties, (p) => p.schema.type);
+        const longest_default = to_max_length(properties, (p) => print_value(p.schema.default));
+        for (const property of properties) {
+            const name = property.name === '_' ? ARGS_PROPERTY_NAME : property.name;
+            logged.push(`\n${st('green', name.padEnd(longest_task_name))} `, st('gray', property.schema.type.padEnd(longest_type)) + ' ', print_value(property.schema.default).padEnd(longest_default) + ' ', property.schema.description || '(no description available)');
+        }
+        if (!properties.length) {
+            logged.push('\n' + st('gray', 'this task has no args'));
+        }
+    }
+    log.info(...logged, '\n');
+};
+// TODO this blocks many usecases like unions, and it's only implemented for CLI arg types, need better support for arbitrary schemas
+const to_arg_properties = (schema, meta, log) => {
+    const { def } = schema;
+    // TODO overly restrictive, support optional objects and/or unions?
+    if (!('shape' in def)) {
+        log.error(`Expected Args for task "${meta.name}" to be an object schema but got ${def.type}`);
+        return [];
+    }
+    const shape = def.shape;
+    const properties = [];
+    for (const name in shape) {
+        if ('no-' + name in shape)
+            continue;
+        const s = shape[name];
+        const schema = {
+            type: to_args_schema_type(s),
+            description: to_args_schema_description(s) || '',
+            default: to_args_schema_default(s),
+        };
+        properties.push({ name, schema });
+    }
+    return properties;
+};
+const to_max_length = (items, toString) => items.reduce((max, m) => Math.max(toString(m).length, max), 0);
+const to_args_schema_type = (schema) => {
+    const { def } = schema._zod;
+    switch (def.type) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'int':
+            return 'int';
+        case 'boolean':
+            return 'boolean';
+        case 'bigint':
+            return 'bigint';
+        case 'symbol':
+            return 'symbol';
+        case 'null':
+            return 'null';
+        case 'undefined':
+            return 'undefined';
+        case 'void':
+            return 'void';
+        case 'never':
+            return 'never';
+        case 'any':
+            return 'any';
+        case 'unknown':
+            return 'unknown';
+        case 'date':
+            return 'date';
+        case 'object':
+            return 'object';
+        case 'record':
+            return 'record';
+        case 'file':
+            return 'file';
+        case 'array':
+            // TODO other types, only handling a subset of CLI arg cases
+            return 'Array<string>';
+        case 'tuple':
+            return 'tuple';
+        case 'union':
+            // TODO fix, this is a hacky way to handle unions for CLI args
+            return 'string | Array<string>';
+        case 'intersection':
+            return 'intersection';
+        case 'map':
+            return 'map';
+        case 'set':
+            return 'set';
+        case 'enum':
+            return schema.options
+                .map((v) => `'${v}'`)
+                .join(' | ');
+        case 'literal':
+            return def.values.map((v) => print_value(v)).join(' | ');
+        case 'nullable': {
+            const subschema = to_subschema(def);
+            return subschema ? to_args_schema_type(subschema) + ' | null' : 'nullable';
+        }
+        case 'optional': {
+            const subschema = to_subschema(def);
+            return subschema ? to_args_schema_type(subschema) + ' | undefined' : 'optional';
+        }
+        case 'success':
+            return 'success';
+        case 'catch':
+            return 'catch';
+        case 'nan':
+            return 'NaN';
+        case 'readonly':
+            return 'readonly';
+        case 'template_literal':
+            return 'template_literal';
+        case 'promise':
+            return 'promise';
+        case 'lazy':
+            return 'lazy';
+        case 'custom':
+            return 'custom';
+        // Unwrap these:
+        // case 'nonoptional':
+        // case 'transform':
+        // case 'default':
+        // case 'prefault':
+        // case 'pipe':
+        default: {
+            const subschema = to_subschema(def);
+            return subschema ? to_args_schema_type(subschema) : def.type;
+        }
+    }
+};
+const to_args_schema_description = (schema) => {
+    const meta = schema.meta();
+    if (meta?.description) {
+        return meta.description;
+    }
+    const subschema = to_subschema(schema.def);
+    if (subschema) {
+        return to_args_schema_description(subschema);
+    }
+    return null;
+};
+const to_args_schema_default = (schema) => {
+    const { def } = schema._zod;
+    if ('defaultValue' in def) {
+        return def.defaultValue;
+    }
+    const subschema = to_subschema(def);
+    if (subschema) {
+        return to_args_schema_default(subschema);
+    }
+};
+const to_subschema = (def) => {
+    if ('innerType' in def) {
+        return def.innerType;
+    }
+    else if ('in' in def) {
+        return def.in;
+    }
+    else if ('schema' in def) {
+        return def.schema;
+    }
+    return undefined;
+};

package/dist/test.task.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dir: z.ZodDefault<z.ZodString>;
+    fail_without_tests: z.ZodDefault<z.ZodBoolean>;
+    t: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=test.task.d.ts.map

package/dist/test.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/test.task.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAOtB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAE/C,cAAc;AACd,eAAO,MAAM,IAAI;;;;;kBAWf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAkC3B,CAAC"}

package/dist/test.task.js

@@ -0,0 +1,53 @@
+import { args_serialize } from '@fuzdev/fuz_util/args.js';
+import { spawn_result_to_message } from '@fuzdev/fuz_util/process.js';
+import { spawn_cli } from './cli.js';
+import { z } from 'zod';
+import { to_implicit_forwarded_args } from "./args.js";
+import { find_cli } from "./cli.js";
+import { VITEST_CLI } from "./constants.js";
+import { package_json_has_dependency, package_json_load } from "./package_json.js";
+import { paths } from "./paths.js";
+import { TaskError } from "./task.js";
+/** @nodocs */
+export const Args = z.strictObject({
+    _: z.array(z.string()).meta({ description: 'file patterns to filter tests' }).default(['.test.']),
+    dir: z.string().meta({ description: 'working directory for tests' }).default(paths.source),
+    fail_without_tests: z
+        .boolean()
+        .meta({ description: 'opt out of `passWithNoTests`' })
+        .default(false),
+    t: z
+        .string()
+        .meta({ description: 'search pattern for test names, same as vitest -t and --testNamePattern' })
+        .optional(),
+});
+/** @nodocs */
+export const task = {
+    summary: 'run tests with vitest',
+    Args,
+    run: async ({ args }) => {
+        const { _: patterns, dir, fail_without_tests, t } = args;
+        const package_json = await package_json_load();
+        if (!package_json_has_dependency(VITEST_CLI, package_json)) {
+            throw new TaskError('no test runner found, install vitest');
+        }
+        if (!(await find_cli(VITEST_CLI))) {
+            throw new TaskError('vitest is a dependency but not installed; run `npm i`?');
+        }
+        const vitest_args = ['run', ...patterns];
+        if (dir) {
+            vitest_args.push('--dir', dir);
+        }
+        if (!fail_without_tests) {
+            vitest_args.push('--passWithNoTests');
+        }
+        if (t) {
+            vitest_args.push('-t', t);
+        }
+        vitest_args.push(...args_serialize(to_implicit_forwarded_args(VITEST_CLI)));
+        const spawned = await spawn_cli(VITEST_CLI, vitest_args);
+        if (!spawned?.ok) {
+            throw new TaskError(`vitest failed: ${spawned ? spawn_result_to_message(spawned) : 'unknown error'}`);
+        }
+    },
+};

package/dist/typecheck.task.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    svelte_check_cli: z.ZodDefault<z.ZodString>;
+    typescript_cli: z.ZodDefault<z.ZodString>;
+    path_replacement: z.ZodDefault<z.ZodString>;
+    cwd: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=typecheck.task.d.ts.map

package/dist/typecheck.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/typecheck.task.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAQtB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAE/C,cAAc;AACd,eAAO,MAAM,IAAI;;;;;kBAcf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAiD3B,CAAC"}

package/dist/typecheck.task.js

@@ -0,0 +1,68 @@
+import { args_serialize } from '@fuzdev/fuz_util/args.js';
+import { print_spawn_result } from '@fuzdev/fuz_util/process.js';
+import { z } from 'zod';
+import { to_forwarded_args } from "./args.js";
+import { configure_colored_output_with_path_replacement } from "./child_process_logging.js";
+import { find_cli, spawn_cli, spawn_cli_process } from "./cli.js";
+import { SVELTE_CHECK_CLI } from "./constants.js";
+import { paths } from "./paths.js";
+import { sveltekit_sync_if_available } from "./sveltekit_helpers.js";
+import { TaskError } from "./task.js";
+/** @nodocs */
+export const Args = z.strictObject({
+    svelte_check_cli: z
+        .string()
+        .meta({ description: 'the svelte-check CLI to use' })
+        .default(SVELTE_CHECK_CLI),
+    typescript_cli: z
+        .string()
+        .meta({ description: 'the TypeScript CLI to use as a fallback to svelte-check' })
+        .default('tsc'),
+    path_replacement: z
+        .string()
+        .meta({ description: 'replacement string for current working directory in output' })
+        .default('.'),
+    cwd: z.string().meta({ description: 'current working directory' }).default(paths.root),
+});
+/** @nodocs */
+export const task = {
+    summary: 'run svelte-check or tsc on the project without emitting any files',
+    Args,
+    run: async ({ args, log }) => {
+        const { svelte_check_cli, typescript_cli, path_replacement, cwd } = args;
+        await sveltekit_sync_if_available();
+        // Prefer svelte-check if available.
+        const found_svelte_check_cli = await find_cli(svelte_check_cli);
+        if (found_svelte_check_cli) {
+            const serialized = args_serialize(to_forwarded_args(svelte_check_cli));
+            const spawned = await spawn_cli_process(found_svelte_check_cli, serialized, undefined, {
+                stdio: ['inherit', 'pipe', 'pipe'],
+                env: { ...process.env, FORCE_COLOR: '1' }, // Needed for colors (maybe make an option)
+            });
+            const svelte_check_process = spawned?.child;
+            if (svelte_check_process) {
+                // Configure process output with path replacement while preserving colors
+                configure_colored_output_with_path_replacement(svelte_check_process, path_replacement, cwd);
+                const svelte_check_result = await spawned.closed;
+                if (!svelte_check_result.ok) {
+                    throw new TaskError(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
+                }
+            }
+            return;
+        }
+        // Fall back to tsc.
+        const found_typescript_cli = await find_cli(typescript_cli);
+        if (found_typescript_cli) {
+            const forwarded = to_forwarded_args(typescript_cli);
+            if (!forwarded.noEmit)
+                forwarded.noEmit = true;
+            const serialized = args_serialize(forwarded);
+            const svelte_check_result = await spawn_cli(found_typescript_cli, serialized, log);
+            if (!svelte_check_result?.ok) {
+                throw new TaskError(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
+            }
+            return;
+        }
+        throw new TaskError(`Failed to typecheck because neither \`${svelte_check_cli}\` nor \`${typescript_cli}\` was found`);
+    },
+};

package/dist/upgrade.task.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    only: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[], string | string[]>>;
+    origin: z.ZodDefault<z.ZodString>;
+    force: z.ZodDefault<z.ZodBoolean>;
+    pull: z.ZodDefault<z.ZodBoolean>;
+    'no-pull': z.ZodDefault<z.ZodBoolean>;
+    delete_node_modules: z.ZodDefault<z.ZodBoolean>;
+    node_modules_path: z.ZodDefault<z.ZodString>;
+    delete_lockfile: z.ZodDefault<z.ZodBoolean>;
+    lockfile_path: z.ZodDefault<z.ZodString>;
+    dry: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=upgrade.task.d.ts.map

package/dist/upgrade.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/upgrade.task.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAUtB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAE/C,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;;;;;;;kBAiCf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA4E3B,CAAC"}