@celljs/cli 3.8.0 → 4.0.0

package/src/build/executable-compiler.ts

@@ -0,0 +1,179 @@
+import { spawnSync } from 'node:child_process';
+import { chmodSync, copyFileSync, existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CellError, type OutputManifest } from '@celljs/kit';
+import type { CompileTarget } from '../config/types.js';
+
+export interface CompileOptions {
+    /** Absolute output directory with the single-file server bundle. */
+    outDir: string;
+    manifest: OutputManifest;
+    compiler: CompileTarget;
+    /** Cross-compilation target of the compiler (`bun-linux-x64`, `x86_64-unknown-linux-gnu`). */
+    target?: string;
+    env: NodeJS.ProcessEnv;
+    info(message: string): void;
+}
+
+type Run = (
+    command: string,
+    args: string[],
+    options?: { cwd?: string; env?: NodeJS.ProcessEnv },
+) => { status: number | null; stdout: string; stderr: string; error?: Error };
+
+/**
+ * `cell build --compile [bun|node|deno]` (docs/design/architecture.md L3): turns the single-file server
+ * bundle, with the frontend inside, into one executable `app` in the output directory. Bun and Deno
+ * compile it themselves; Node.js uses a single executable application (SEA: a CommonJS bundle
+ * injected into a copy of node with postject).
+ */
+export class ExecutableCompiler {
+    static readonly SEA_FUSE = 'NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2';
+    static readonly POSTJECT = 'postject@1.0.0-alpha.6';
+
+    constructor(
+        protected readonly options: CompileOptions,
+        protected readonly run: Run = ExecutableCompiler.spawn,
+    ) {}
+
+    static spawn: Run = (command, args, options = {}) => {
+        const result = spawnSync(command, args, { cwd: options.cwd, env: options.env, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+        return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '', error: result.error };
+    };
+
+    get file(): string {
+        const windows = this.options.target ? /windows|win32|msvc/.test(this.options.target) : process.platform === 'win32';
+        return windows ? 'app.exe' : 'app';
+    }
+
+    compile(): OutputManifest {
+        const { outDir, manifest, compiler, target } = this.options;
+        if (!manifest.server) {
+            throw new CellError({
+                code: 'CELL_COMPILE_NO_SERVER',
+                message: 'There is no server to compile: the project builds no backend.',
+                hint: 'Build without --compile, or add a backend to the project.',
+            });
+        }
+        this.checkNoExternals();
+        const output = join(outDir, this.file);
+        rmSync(output, { force: true });
+        this.options.info(`Compiling ${manifest.server} into ${this.file} with ${compiler}${target ? ` (${target})` : ''}…`);
+        switch (compiler) {
+            case 'bun':
+                this.exec(
+                    'bun',
+                    ['build', join(outDir, manifest.server), '--compile', '--outfile', output, ...(target ? ['--target', target] : [])],
+                    'https://bun.sh',
+                );
+                break;
+            case 'deno':
+                this.exec(
+                    'deno',
+                    ['compile', '--allow-all', '--no-check', '--output', output, ...(target ? ['--target', target] : []), join(outDir, manifest.server)],
+                    'https://deno.com',
+                );
+                break;
+            case 'node':
+                this.node(join(outDir, manifest.server), output);
+                break;
+        }
+        if (!existsSync(output)) {
+            throw new CellError({
+                code: 'CELL_COMPILE_FAILED',
+                message: `${compiler} finished without writing ${output}.`,
+                hint: 'Rerun with CELL_DEBUG=1 and report it.',
+            });
+        }
+        return { ...manifest, executable: { file: this.file, compiler, ...(target ? { target } : {}) } };
+    }
+
+    /** Packages copied next to the bundle (native modules, `build.external`) cannot go into the executable. */
+    protected checkNoExternals(): void {
+        const dir = join(this.options.outDir, 'server', 'node_modules');
+        if (!existsSync(dir)) {
+            return;
+        }
+        const names = readdirSync(dir)
+            .filter(name => !name.startsWith('.'))
+            .flatMap(name => (name.startsWith('@') ? readdirSync(join(dir, name)).map(sub => `${name}/${sub}`) : [name]));
+        if (names.length > 0) {
+            throw new CellError({
+                code: 'CELL_COMPILE_EXTERNALS',
+                message: `The executable cannot contain the packages that stay outside the server bundle: ${names.join(', ')}.`,
+                hint: 'Remove them from build.external (and from the optionalDependencies of components) so they are bundled, or ship .cell/output without --compile.',
+            });
+        }
+    }
+
+    /** Node.js SEA: the blob of the CommonJS bundle, injected into a copy of the node executable. */
+    protected node(server: string, output: string): void {
+        if (this.options.manifest.format !== 'cjs') {
+            throw new CellError({
+                code: 'CELL_CONFIG_CONFLICT',
+                message: 'A Node.js executable needs a CommonJS server bundle.',
+                hint: 'Build with --compile node and without --format esm.',
+            });
+        }
+        if (this.options.target) {
+            throw new CellError({
+                code: 'CELL_ARGUMENT_INVALID',
+                message: 'Node.js executables cannot be cross-compiled: --compile-target is for bun and deno.',
+                hint: 'Build on the platform you target, or use --compile bun --compile-target <target>.',
+            });
+        }
+        const work = mkdtempSync(join(tmpdir(), 'cell-sea-'));
+        try {
+            const blob = join(work, 'sea-prep.blob');
+            writeFileSync(join(work, 'sea-config.json'), JSON.stringify({ main: server, output: blob, disableExperimentalSEAWarning: true }));
+            this.exec('node', ['--experimental-sea-config', join(work, 'sea-config.json')], 'https://nodejs.org', work);
+            const node = this.exec('node', ['-p', 'process.execPath'], 'https://nodejs.org').trim();
+            copyFileSync(node, output);
+            chmodSync(output, 0o755);
+            const mac = process.platform === 'darwin';
+            if (mac) {
+                this.exec('codesign', ['--remove-signature', output], 'Xcode command line tools');
+            }
+            this.exec(
+                'npx',
+                [
+                    '--yes',
+                    ExecutableCompiler.POSTJECT,
+                    output,
+                    'NODE_SEA_BLOB',
+                    blob,
+                    '--sentinel-fuse',
+                    ExecutableCompiler.SEA_FUSE,
+                    ...(mac ? ['--macho-segment-name', 'NODE_SEA'] : []),
+                ],
+                'npm',
+            );
+            if (mac) {
+                this.exec('codesign', ['--sign', '-', output], 'Xcode command line tools');
+            }
+        } finally {
+            rmSync(work, { recursive: true, force: true });
+        }
+    }
+
+    protected exec(command: string, args: string[], install: string, cwd?: string): string {
+        const result = this.run(command, args, { cwd, env: this.options.env });
+        if (result.error && (result.error as NodeJS.ErrnoException).code === 'ENOENT') {
+            throw new CellError({
+                code: 'CELL_COMPILE_TOOL_MISSING',
+                message: `${command} is not installed, and --compile ${this.options.compiler} needs it.`,
+                hint: `Install it (${install}) or compile with another tool: --compile bun, --compile node or --compile deno.`,
+            });
+        }
+        if (result.status !== 0) {
+            const output = `${result.stderr}\n${result.stdout}`.trim().split('\n').slice(-15).join('\n');
+            throw new CellError({
+                code: 'CELL_COMPILE_FAILED',
+                message: `${command} ${args[0]} failed with exit code ${result.status}: ${output || 'no output'}`,
+                hint: 'Fix what the compiler reports; the single-file bundle it compiled is in the output directory.',
+            });
+        }
+        return result.stdout;
+    }
+}

package/src/check/project-checker.ts

@@ -0,0 +1,365 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { CellError, type CheckIssue } from '@celljs/kit';
+import { CellDevServer, ProjectLoader } from '@celljs/vite';
+import { ProjectInspector } from '../info/project-inspector.js';
+import type { Toolchain } from '../toolchain/toolchain.js';
+
+/** The outcome of one check. */
+export interface CheckReport {
+    name: string;
+    description: string;
+    /** Module that registered the check; absent for the built-in ones. */
+    source?: string;
+    durationMs: number;
+    issues: CheckIssue[];
+    /** Why the check did not run. */
+    skipped?: string;
+}
+
+interface Check {
+    name: string;
+    description: string;
+    source?: string;
+    run(): Promise<CheckIssue[] | { skipped: string }>;
+}
+
+/** Shapes of inversify errors and the codes `cell check` gives them (docs/design/agent-first.md R5). */
+const DI_ERRORS: [RegExp, string, string][] = [
+    [
+        /^No matching bindings found for serviceIdentifier: (.+)/,
+        'CELL_DI_NO_BINDING',
+        'Bind the identifier in a DI module (@Component), or mark the injection @Optional().',
+    ],
+    [
+        /^Ambiguous match found for serviceIdentifier: (.+)/,
+        'CELL_DI_AMBIGUOUS',
+        'Inject all of them with @Autowired(...) on an array, give one rebind: true, or name them.',
+    ],
+    [/^Circular dependency found: (.+)/, 'CELL_DI_CIRCULAR', 'Break the cycle: inject lazily, or move the shared part into another component.'],
+    [/^Missing required @inject or @multiInject annotation/, 'CELL_DI_MISSING_INJECT', 'Add @Autowired(...) to the constructor parameter or property.'],
+];
+
+/**
+ * `cell check` (docs/design/agent-first.md R4): the checks that tell before running whether the
+ * project works: configuration, TypeScript types, decorator settings, DI bindings of the backend,
+ * and the checks of toolchain modules. Every finding is a CheckIssue with a stable code.
+ */
+export class ProjectChecker {
+    static readonly BUILTIN = ['config', 'types', 'decorators', 'di'];
+
+    constructor(
+        protected readonly toolchain: Toolchain,
+        protected readonly options: { env?: NodeJS.ProcessEnv; skip?: string[] } = {},
+    ) {}
+
+    get root(): string {
+        return this.toolchain.config.root;
+    }
+
+    /** Names of the checks that `--skip` accepts. */
+    get names(): string[] {
+        return this.checks().map(check => check.name);
+    }
+
+    async run(): Promise<CheckReport[]> {
+        const skip = new Set(this.options.skip ?? []);
+        const unknown = [...skip].filter(name => !this.names.includes(name));
+        if (unknown.length > 0) {
+            throw new CellError({
+                code: 'CELL_ARGUMENT_INVALID',
+                message: `Unknown check '${unknown[0]}'. Checks: ${this.names.join(', ')}.`,
+                hint: 'Pass a check name to --skip.',
+            });
+        }
+        const reports: CheckReport[] = [];
+        for (const check of this.checks()) {
+            const started = performance.now();
+            const base = { name: check.name, description: check.description, ...(check.source ? { source: check.source } : {}) };
+            if (skip.has(check.name)) {
+                reports.push({ ...base, durationMs: 0, issues: [], skipped: '--skip' });
+                continue;
+            }
+            let outcome: CheckIssue[] | { skipped: string };
+            try {
+                outcome = await check.run();
+            } catch (error) {
+                const failure = CellError.is(error) ? error : undefined;
+                outcome = [
+                    {
+                        level: 'error',
+                        code: failure?.code ?? 'CELL_CHECK_FAILED',
+                        message: failure?.message ?? `The ${check.name} check failed: ${(error as Error)?.message ?? String(error)}`,
+                        ...(failure?.file ? { file: failure.file } : {}),
+                        ...(failure?.line ? { line: failure.line } : {}),
+                        ...(failure?.hint ? { hint: failure.hint } : {}),
+                    },
+                ];
+            }
+            const durationMs = Math.round(performance.now() - started);
+            reports.push(Array.isArray(outcome) ? { ...base, durationMs, issues: outcome } : { ...base, durationMs, issues: [], skipped: outcome.skipped });
+        }
+        return reports;
+    }
+
+    protected checks(): Check[] {
+        const builtin: Check[] = [
+            { name: 'config', description: 'cell.config.ts, cell*.yml, modes, entries and environment overrides', run: async () => this.config() },
+            { name: 'types', description: 'TypeScript types (tsc --noEmit)', run: () => this.types() },
+            { name: 'decorators', description: 'tsconfig settings the DI decorators need', run: async () => this.decorators() },
+            { name: 'di', description: 'every DI binding of the backend resolves', run: () => this.di() },
+        ];
+        const modules = this.toolchain.modules.checks.map(({ source, value }) => ({
+            name: value.name,
+            description: value.description,
+            source,
+            run: async () => value.run({ root: this.root, mode: this.toolchain.config.mode, project: this.project() }),
+        }));
+        return [...builtin, ...modules];
+    }
+
+    protected project() {
+        return new ProjectLoader({ ...this.toolchain.projectOptions(), env: this.options.env }).load();
+    }
+
+    protected config(): CheckIssue[] {
+        const { config, preset, presets, modules } = this.toolchain;
+        const inspector = new ProjectInspector(config, preset, presets.names, { projectOptions: this.toolchain.projectOptions(), modules: modules.loaded });
+        inspector.inspect({ env: this.options.env });
+        return inspector.issues;
+    }
+
+    /** The nearest tsconfig.json of the project, with `extends` of relative files merged. */
+    protected tsconfig(): { file: string; compilerOptions: Record<string, unknown> } | undefined {
+        const file = join(this.root, 'tsconfig.json');
+        if (!existsSync(file)) {
+            return undefined;
+        }
+        const read = (path: string, seen: Set<string>): Record<string, unknown> => {
+            const json = ProjectChecker.parseJsonc(readFileSync(path, 'utf8')) as { extends?: string | string[]; compilerOptions?: Record<string, unknown> };
+            const bases = [json.extends ?? []].flat().filter(base => base.startsWith('.') || isAbsolute(base));
+            let options: Record<string, unknown> = {};
+            for (const base of bases) {
+                const target = resolve(dirname(path), base.endsWith('.json') ? base : `${base}.json`);
+                if (existsSync(target) && !seen.has(target)) {
+                    seen.add(target);
+                    options = { ...options, ...read(target, seen) };
+                }
+            }
+            return { ...options, ...(json.compilerOptions ?? {}) };
+        };
+        return { file, compilerOptions: read(file, new Set([file])) };
+    }
+
+    protected decorators(): CheckIssue[] | { skipped: string } {
+        const tsconfig = this.tsconfig();
+        if (!tsconfig) {
+            return { skipped: 'no tsconfig.json' };
+        }
+        const missing = ['experimentalDecorators', 'emitDecoratorMetadata'].filter(option => tsconfig.compilerOptions[option] !== true);
+        return missing.map(option => ({
+            level: 'warning' as const,
+            code: 'CELL_TSCONFIG_DECORATORS',
+            message: `tsconfig.json does not set ${option}: true. Cell builds with legacy decorators and their metadata, so tsc and editors check a different program.`,
+            file: tsconfig.file,
+            hint: `Set "${option}": true in compilerOptions.`,
+        }));
+    }
+
+    protected async types(): Promise<CheckIssue[] | { skipped: string }> {
+        const tsconfig = this.tsconfig();
+        if (!tsconfig) {
+            return { skipped: 'no tsconfig.json' };
+        }
+        let tsc: string;
+        try {
+            const require = createRequire(join(this.root, 'package.json'));
+            const manifest = require.resolve('typescript/package.json');
+            const bin = (JSON.parse(readFileSync(manifest, 'utf8')) as { bin?: Record<string, string> }).bin?.tsc;
+            if (!bin) {
+                return { skipped: 'the installed typescript has no tsc' };
+            }
+            tsc = join(dirname(manifest), bin);
+        } catch {
+            return { skipped: 'typescript is not installed' };
+        }
+        const output = await new Promise<string>((resolvePromise, reject) => {
+            const child = spawn(process.execPath.includes('bun') ? 'node' : process.execPath, [tsc, '--noEmit', '--pretty', 'false', '-p', tsconfig.file], {
+                cwd: this.root,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let text = '';
+            child.stdout.on('data', chunk => {
+                text += chunk;
+            });
+            child.stderr.on('data', chunk => {
+                text += chunk;
+            });
+            child.on('error', reject);
+            child.on('close', () => resolvePromise(text));
+        });
+        return ProjectChecker.parseTsc(output, this.root);
+    }
+
+    /** `file(line,col): error TS1234: message`, with indented continuation lines. */
+    static parseTsc(output: string, root: string): CheckIssue[] {
+        const issues: CheckIssue[] = [];
+        for (const line of output.split(/\r?\n/)) {
+            const match = /^(.+?)\((\d+),(\d+)\): (error|warning) (TS\d+): (.*)$/.exec(line);
+            if (match) {
+                issues.push({
+                    level: match[4] === 'error' ? 'error' : 'warning',
+                    code: match[5],
+                    message: match[6],
+                    file: resolve(root, match[1]),
+                    line: Number(match[2]),
+                    column: Number(match[3]),
+                });
+            } else if (/^\s+\S/.test(line) && issues.length > 0) {
+                issues[issues.length - 1].message += `\n${line.trim()}`;
+            } else if (/^error (TS\d+): (.*)$/.test(line)) {
+                const [, tsCode, message] = /^error (TS\d+): (.*)$/.exec(line) ?? [];
+                issues.push({ level: 'error', code: tsCode, message });
+            }
+        }
+        return issues;
+    }
+
+    /** Loads the backend's container (not the application) and resolves every binding. */
+    protected async di(): Promise<CheckIssue[] | { skipped: string }> {
+        const options = this.toolchain.projectOptions();
+        const server = new CellDevServer({
+            ...options,
+            mode: this.toolchain.config.mode,
+            env: this.options.env,
+            vite: this.toolchain.config.vite,
+            plugins: this.toolchain.modules.vitePlugins(),
+            listen: false,
+            backend: false,
+            logLevel: 'silent',
+        });
+        await server.start();
+        try {
+            if (!server.project.backend) {
+                return { skipped: 'no backend target' };
+            }
+            let container: InversifyContainer;
+            try {
+                container = await (await server.import<{ container: Promise<InversifyContainer> }>('@celljs/core/lib/common/container/dynamic-container'))
+                    .container;
+                // Components look the container up through ContainerProvider, as the entry sets it.
+                const { ContainerProvider } = await server.import<{ ContainerProvider: { set(c: unknown): void } }>(
+                    '@celljs/core/lib/common/container/container-provider',
+                );
+                ContainerProvider.set(container);
+            } catch (error) {
+                throw CellDevServer.toCellError(error, 'CELL_DI_MODULE_FAILED');
+            }
+            return ProjectChecker.resolveAll(container);
+        } finally {
+            await server.close();
+        }
+    }
+
+    /**
+     * Resolves every binding. One cause (a missing binding, a cycle) breaks every binding that depends
+     * on it: it is reported once, from the binding that needs it, with the count of the others.
+     */
+    static async resolveAll(container: InversifyContainer): Promise<CheckIssue[]> {
+        const causes = new Map<string, { issue: CheckIssue; requester?: string; count: number }>();
+        for (const id of container._bindingDictionary.getMap().keys()) {
+            try {
+                await container.getAllAsync(id);
+            } catch (error) {
+                const issue = ProjectChecker.diIssue(id, error);
+                const { cause, requester } = ProjectChecker.diCause(error);
+                const found = causes.get(cause);
+                if (!found) {
+                    causes.set(cause, { issue, requester, count: 1 });
+                } else {
+                    found.count++;
+                    if (requester && ProjectChecker.identifierName(id) === requester) {
+                        found.issue = issue;
+                    }
+                }
+            }
+        }
+        return [...causes.values()].map(({ issue, count }) =>
+            count === 1 ? issue : { ...issue, message: `${issue.message}; ${count - 1} other binding${count === 2 ? '' : 's'} fail because of it` },
+        );
+    }
+
+    /** What failed, without the binding it was resolved from; and the binding that needs it. */
+    protected static diCause(error: unknown): { cause: string; requester?: string } {
+        const text = String((error as Error)?.message ?? error);
+        const path = /Trying to resolve bindings for "([^"]+)"/.exec(text)?.[1];
+        return { cause: `${text.split('\n')[0].trim()}\0${path ?? ''}`, requester: path?.split(' --> ').pop()?.trim() };
+    }
+
+    static identifierName(id: unknown): string {
+        if (typeof id === 'symbol') {
+            return id.description ?? id.toString();
+        }
+        if (typeof id === 'function') {
+            return id.name || '(anonymous class)';
+        }
+        return String(id);
+    }
+
+    static diIssue(id: unknown, error: unknown): CheckIssue {
+        const text = String((error as Error)?.message ?? error);
+        const first = text.split('\n')[0];
+        const known = DI_ERRORS.find(([pattern]) => pattern.test(first));
+        // inversify appends "Trying to resolve bindings for 'A --> B'" and the registered bindings.
+        const path = /Trying to resolve bindings for "([^"]+)"/.exec(text)?.[1];
+        const message = `Resolving ${ProjectChecker.identifierName(id)}: ${first.trim()}${path ? ` (${path})` : ''}`;
+        return known
+            ? { level: 'error', code: known[1], message, hint: known[2] }
+            : {
+                  // Bindings made for an injection point (`@Value`) or a request cannot be created on their own; not a finding.
+                  level: 'info',
+                  code: 'CELL_DI_CONSTRUCT_FAILED',
+                  message,
+                  hint: 'Creating it on its own failed; that is expected for bindings that need an injection point, a request or a started application.',
+              };
+    }
+
+    /** JSON with comments and trailing commas, as tsconfig.json allows. */
+    static parseJsonc(text: string): unknown {
+        let out = '';
+        let inString = false;
+        for (let i = 0; i < text.length; i++) {
+            const char = text[i];
+            if (inString) {
+                out += char;
+                if (char === '\\') {
+                    out += text[++i] ?? '';
+                } else if (char === '"') {
+                    inString = false;
+                }
+            } else if (char === '"') {
+                inString = true;
+                out += char;
+            } else if (char === '/' && text[i + 1] === '/') {
+                while (i < text.length && text[i] !== '\n') {
+                    i++;
+                }
+                out += '\n';
+            } else if (char === '/' && text[i + 1] === '*') {
+                i = text.indexOf('*/', i + 2);
+                i = i < 0 ? text.length : i + 1;
+            } else {
+                out += char;
+            }
+        }
+        return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1'));
+    }
+}
+
+/** The part of an inversify Container that the DI check uses. */
+interface InversifyContainer {
+    _bindingDictionary: { getMap(): Map<unknown, unknown[]> };
+    getAllAsync(id: unknown): Promise<unknown[]>;
+}

package/src/cli/agent-command.ts

@@ -0,0 +1,46 @@
+import { CellError } from '@celljs/kit';
+import { AgentGuide } from '../agent/agent-guide.js';
+import { Toolchain } from '../toolchain/toolchain.js';
+import { Command, type CommandContext } from './command.js';
+
+/**
+ * `cell agent sync`: writes the agent guide of the installed versions into AGENTS.md (between
+ * markers) and `.agents/skills/cell/SKILL.md`: the Cell guide of this CLI and the AGENTS.md of
+ * every component and toolchain module (docs/design/agent-first.md R7).
+ */
+export class AgentCommand extends Command {
+    readonly name = 'agent';
+    readonly description = 'Write AGENTS.md and the cell skill for the installed versions';
+    override readonly arguments = 'sync';
+
+    constructor(protected readonly version: () => string) {
+        super();
+    }
+
+    async run({ values, positionals, reporter, env }: CommandContext): Promise<number> {
+        if (positionals.length !== 1 || positionals[0] !== 'sync') {
+            throw new CellError({
+                code: 'CELL_ARGUMENT_INVALID',
+                message: `Unknown agent action '${positionals.join(' ')}'.`,
+                hint: 'Use cell agent sync.',
+            });
+        }
+        const toolchain = await Toolchain.create({
+            root: values.root as string | undefined,
+            command: 'info',
+            env,
+            quiet: reporter.json,
+            runHooks: false,
+            logger: reporter,
+        });
+        await toolchain.close();
+        const snippets = AgentGuide.snippets(toolchain.modules.components, toolchain.modules.docs);
+        const result = new AgentGuide(toolchain.config.root, this.version()).sync(snippets);
+        reporter.result(
+            'agent',
+            { root: toolchain.config.root, ...result },
+            `Wrote ${result.files.join(', ')}${result.snippets.length > 0 ? ` with the guides of ${result.snippets.join(', ')}` : ''}`,
+        );
+        return 0;
+    }
+}