@codefast/cli 0.10.0 → 0.12.0

package/dist/tag/cli-schema.js

@@ -1,13 +1,12 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
- * Zod schema validating a `TagSyncRunRequest`.
+ * Zod schema validating a `TagRunRequest`.
  *
  * @since 0.3.16-canary.0
  */
-export const tagSyncRunRequestSchema = z.object({
+export const tagRunRequestSchema = z.object({
     rootDir: z.string().min(1),
     write: z.boolean(),
-    json: z.boolean().optional(),
     targetPath: z.string().optional(),
     skipPackages: z.array(z.string()).optional(),
     config: z.unknown().optional(),

package/dist/tag/command.js

@@ -1,70 +1,43 @@
-import process from "node:process";
 import { Command } from "commander";
-import { readOptionalPositionalArg } from "#/core/cli/positional";
-import { consumeCliAppError } from "#/core/cli/result-handle";
-import { nodeFilesystem } from "#/core/filesystem/node";
-import { logger } from "#/core/logger";
-import { parseWithSchema } from "#/core/schema-parse";
-import { exitCodeForTagSyncResult } from "#/tag/cli-result";
-import { tagSyncRunRequestSchema } from "#/tag/cli-schema";
-import { presentTagSyncResult, TagSyncProgressPresenter } from "#/tag/output";
-import { prepareTagSync } from "#/tag/prepare";
-import { runTagSync } from "#/tag/sync";
+import { applyCommandPipeline } from "#core/cli/command-pipeline";
+import { nodeFilesystem } from "#core/filesystem/node";
+import { exitCodeForTagResult, formatTagJsonOutput } from "#tag/cli-result";
+import { tagRunRequestSchema } from "#tag/cli-schema";
+import { presentTagResult, TagProgressPresenter } from "#tag/output";
+import { prepareTag } from "#tag/prepare";
+import { runTag } from "#tag/run";
+const tagPipeline = {
+    positional: { name: "[target]", help: "Directory or file to tag (default: auto-discover workspace packages)" },
+    schema: tagRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Show summary without writing files", false);
+    },
+    prepare: (fs, input) => prepareTag(fs, { currentWorkingDirectory: input.currentWorkingDirectory, rawTarget: input.rawArg }),
+    buildRequest: ({ prelude, opts }) => {
+        const tagConfig = prelude.config.tag ?? {};
+        return {
+            rootDir: prelude.rootDir,
+            write: !opts.dryRun,
+            targetPath: prelude.resolvedTargetPath,
+            skipPackages: tagConfig.skipPackages,
+            config: tagConfig,
+        };
+    },
+    createPresenter: () => new TagProgressPresenter(),
+    run: (fs, request, presenter) => runTag(fs, { ...request, listener: presenter }),
+    presentHuman: ({ result, prelude }) => {
+        presentTagResult(result, prelude.rootDir);
+    },
+    formatJson: ({ result, prelude }) => formatTagJsonOutput(result, prelude.rootDir),
+    exitCode: exitCodeForTagResult,
+};
 /**
  * Creates the `tag` subcommand, which stamps `@since` tags on exported declarations.
  *
  * @since 0.3.16-canary.0
  */
 export function createTagCommand() {
-    const cmd = new Command("tag")
-        .description("Add @since <version> JSDoc tags to exported declarations")
-        .argument("[target]", "Directory or file to tag (default: auto-discover workspace packages)")
-        .option("--dry-run", "Show summary without writing files", false)
-        .option("--json", "Print one JSON summary on stdout (suppresses human progress)", false)
-        .action(async (target, opts) => {
-        const prelude = await prepareTagSync(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { rootDir, config, resolvedTargetPath } = prelude.value;
-        const tagConfig = config.tag ?? {};
-        const parsed = parseWithSchema(tagSyncRunRequestSchema, {
-            rootDir,
-            write: !opts.dryRun,
-            json: opts.json,
-            targetPath: resolvedTargetPath,
-            skipPackages: tagConfig.skipPackages,
-            config: tagConfig,
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        const progressPresenter = new TagSyncProgressPresenter();
-        const tagOutcome = await runTagSync(nodeFilesystem, {
-            ...parsed.value,
-            listener: parsed.value.json ? undefined : progressPresenter,
-        });
-        if (!consumeCliAppError(tagOutcome)) {
-            return;
-        }
-        if (parsed.value.json) {
-            logger.out(formatTagSyncJsonOutput(tagOutcome.value, rootDir));
-            process.exitCode = exitCodeForTagSyncResult(tagOutcome.value);
-        }
-        else {
-            process.exitCode = presentTagSyncResult(tagOutcome.value, rootDir);
-        }
-    });
+    const cmd = new Command("tag").description("Add @since <version> JSDoc tags to exported declarations");
+    applyCommandPipeline(cmd, nodeFilesystem, tagPipeline);
     return cmd;
-}
-function formatTagSyncJsonOutput(result, rootDir) {
-    return JSON.stringify({
-        schemaVersion: 1,
-        ok: result.hookError === null,
-        cwd: rootDir,
-        result,
-    });
 }

package/dist/tag/domain/skip-filter.d.ts

@@ -0,0 +1,13 @@
+import type { TagTargetCandidate } from "#tag/domain/types";
+/**
+ * Partitions tag target candidates into those to tag and those to skip, matching each candidate's
+ * package name against `skipPackages` as glob patterns.
+ *
+ * @remarks Candidates without a package name (e.g. an explicit-target path) are never skipped.
+ *
+ * @since 0.5.0-canary.0
+ */
+export declare function filterSkippedCandidates(targetCandidates: Array<TagTargetCandidate>, skipPackages: ReadonlyArray<string> | undefined): {
+    includedCandidates: Array<TagTargetCandidate>;
+    skippedPackages: Array<string>;
+};

package/dist/tag/domain/skip-filter.js

@@ -0,0 +1,29 @@
+import { createAnyGlobMatcher } from "#core/glob";
+/**
+ * Partitions tag target candidates into those to tag and those to skip, matching each candidate's
+ * package name against `skipPackages` as glob patterns.
+ *
+ * @remarks Candidates without a package name (e.g. an explicit-target path) are never skipped.
+ *
+ * @since 0.5.0-canary.0
+ */
+export function filterSkippedCandidates(targetCandidates, skipPackages) {
+    if (!skipPackages || skipPackages.length === 0) {
+        return {
+            includedCandidates: targetCandidates,
+            skippedPackages: [],
+        };
+    }
+    const isSkipped = createAnyGlobMatcher(skipPackages);
+    const includedCandidates = [];
+    const skippedPackages = [];
+    for (const candidate of targetCandidates) {
+        const packageName = candidate.packageName;
+        if (packageName && isSkipped(packageName)) {
+            skippedPackages.push(packageName);
+            continue;
+        }
+        includedCandidates.push(candidate);
+    }
+    return { includedCandidates, skippedPackages };
+}

package/dist/tag/domain/types.d.ts

@@ -1,4 +1,4 @@
-import type { CodefastConfig } from "#/core/config/schema";
+import type { CodefastConfig } from "#core/config/schema";
 /**
  * Per-file outcome of a tag run.
  *
@@ -85,7 +85,7 @@ export interface TagProgressListener {
  *
  * @since 0.3.16-canary.0
  */
-export type TagSyncResult = {
+export type TagResult = {
     mode: "applied" | "dry-run";
     selectedTargets: Array<TagResolvedTarget>;
     skippedPackages: Array<string>;
@@ -108,4 +108,24 @@ export interface TagCommandPrelude {
     readonly config: CodefastConfig;
     readonly resolvedTargetPath: string | undefined;
 }
+/**
+ * The inputs a tag run is invoked with.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagRunRequest = {
+    rootDir: string;
+    write: boolean;
+    targetPath?: string | undefined;
+    skipPackages?: Array<string> | undefined;
+    config?: unknown;
+};
+/**
+ * A run request paired with an optional progress listener.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagExecutionInput = TagRunRequest & {
+    readonly listener?: TagProgressListener | undefined;
+};
 export {};

package/dist/tag/domain/version-summary.d.ts

@@ -0,0 +1,13 @@
+import type { TagTargetExecutionResult } from "#tag/domain/types";
+/**
+ * Collects the distinct, non-empty package versions stamped across a run's target results.
+ *
+ * @since 0.11.0
+ */
+export declare function extractDistinctVersions(targetResults: Array<TagTargetExecutionResult>): Set<string>;
+/**
+ * Summarizes a set of versions as `"none"`, the single version, or `"mixed"`.
+ *
+ * @since 0.11.0
+ */
+export declare function summarizeVersions(distinctVersions: Set<string>): string;

package/dist/tag/domain/version-summary.js

@@ -0,0 +1,24 @@
+/**
+ * Collects the distinct, non-empty package versions stamped across a run's target results.
+ *
+ * @since 0.11.0
+ */
+export function extractDistinctVersions(targetResults) {
+    return new Set(targetResults
+        .map((targetResult) => targetResult.result?.version)
+        .filter((version) => typeof version === "string" && version.length > 0));
+}
+/**
+ * Summarizes a set of versions as `"none"`, the single version, or `"mixed"`.
+ *
+ * @since 0.11.0
+ */
+export function summarizeVersions(distinctVersions) {
+    if (distinctVersions.size === 0) {
+        return "none";
+    }
+    if (distinctVersions.size > 1) {
+        return "mixed";
+    }
+    return distinctVersions.values().next().value ?? "none";
+}

package/dist/tag/output.d.ts

@@ -1,17 +1,17 @@
-import type { TagProgressListener, TagResolvedTarget, TagSyncResult, TagTargetExecutionResult } from "#/tag/domain/types";
+import type { TagProgressListener, TagResolvedTarget, TagResult, TagTargetExecutionResult } from "#tag/domain/types";
 /**
  * A progress listener that prints a line as each tag target starts and completes.
  *
  * @since 0.3.16-canary.0
  */
-export declare class TagSyncProgressPresenter implements TagProgressListener {
+export declare class TagProgressPresenter implements TagProgressListener {
     onTargetStarted(target: TagResolvedTarget): void;
     onTargetCompleted(target: TagResolvedTarget, result: TagTargetExecutionResult): void;
     private static formatProgress;
 }
 /**
- * Prints a tag run's target table, warnings, and summary, and returns the exit code.
+ * Prints a tag run's target table, warnings, and summary to the human reader.
  *
  * @since 0.3.16-canary.0
  */
-export declare function presentTagSyncResult(result: TagSyncResult, rootDir: string): number;
+export declare function presentTagResult(result: TagResult, rootDir: string): void;

package/dist/tag/output.js

@@ -1,17 +1,15 @@
-import { CLI_EXIT_GENERAL_ERROR } from "#/core/exit-codes";
-import { logger } from "#/core/logger";
-import { exitCodeForTagSyncResult } from "#/tag/cli-result";
+import { logger } from "#core/logger";
 /**
  * A progress listener that prints a line as each tag target starts and completes.
  *
  * @since 0.3.16-canary.0
  */
-export class TagSyncProgressPresenter {
+export class TagProgressPresenter {
     onTargetStarted(target) {
-        logger.out(TagSyncProgressPresenter.formatProgress({ type: "target-started", target }));
+        logger.out(TagProgressPresenter.formatProgress({ type: "target-started", target }));
     }
     onTargetCompleted(target, result) {
-        logger.out(TagSyncProgressPresenter.formatProgress({ type: "target-completed", target, result }));
+        logger.out(TagProgressPresenter.formatProgress({ type: "target-completed", target, result }));
     }
     static formatProgress(event) {
         const targetDisplayName = (target) => target.packageName ?? target.rootRelativeTargetPath;
@@ -29,22 +27,21 @@ const colors = {
     yellow: "\x1b[33m",
 };
 /**
- * Prints a tag run's target table, warnings, and summary, and returns the exit code.
+ * Prints a tag run's target table, warnings, and summary to the human reader.
  *
  * @since 0.3.16-canary.0
  */
-export function presentTagSyncResult(result, rootDir) {
+export function presentTagResult(result, rootDir) {
     logger.out(formatTargetTable(result.selectedTargets, rootDir));
     if (result.selectedTargets.length === 0) {
         logger.err("No packages found in workspace. Check your pnpm-workspace.yaml or provide an explicit target path.");
-        return CLI_EXIT_GENERAL_ERROR;
+        return;
     }
     const warningsAndErrorsSection = formatWarningsAndErrors(result);
     if (warningsAndErrorsSection) {
         logger.err(warningsAndErrorsSection);
     }
     logger.out(formatSummary(result));
-    return exitCodeForTagSyncResult(result);
 }
 function withColorizedLine(line, colorCode) {
     return `${colorCode}${line}${colorReset}`;

package/dist/tag/prepare.d.ts

@@ -1,13 +1,13 @@
-import type { AppError } from "#/core/errors";
-import type { FilesystemPort } from "#/core/filesystem/port";
-import type { Result } from "#/core/result";
-import type { TagCommandPrelude } from "#/tag/domain/types";
+import type { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
+import type { TagCommandPrelude } from "#tag/domain/types";
 /**
  * Resolves the repo root, config, and optional target path into the prelude a tag run starts from.
  *
  * @since 0.3.16-canary.0
  */
-export declare function prepareTagSync(fs: FilesystemPort, args: {
+export declare function prepareTag(fs: Filesystem, args: {
     readonly currentWorkingDirectory: string;
     readonly rawTarget: string | undefined;
 }): Promise<Result<TagCommandPrelude, AppError>>;

package/dist/tag/prepare.js

@@ -1,13 +1,13 @@
-import { loadCodefastConfig } from "#/core/config";
-import { ok } from "#/core/result";
-import { resolveProjectRoot } from "#/core/workspace/resolver";
-import { resolveProvidedTagTargetPath } from "#/tag/resolve-target-path";
+import { loadCodefastConfig } from "#core/config";
+import { ok } from "#core/result";
+import { resolveProjectRoot } from "#core/workspace/resolver";
+import { resolveProvidedTagTargetPath } from "#tag/target/resolve-path";
 /**
  * Resolves the repo root, config, and optional target path into the prelude a tag run starts from.
  *
  * @since 0.3.16-canary.0
  */
-export async function prepareTagSync(fs, args) {
+export async function prepareTag(fs, args) {
     let rootDir;
     try {
         rootDir = resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir;

package/dist/tag/run.d.ts

@@ -0,0 +1,10 @@
+import { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
+import type { TagExecutionInput, TagResult } from "#tag/domain/types";
+/**
+ * Applies `@since` tags across the selected targets and returns the aggregate result.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function runTag(fs: Filesystem, input: TagExecutionInput): Promise<Result<TagResult, AppError>>;

package/dist/tag/{sync.js → run.js}

@@ -1,26 +1,37 @@
 import path from "node:path";
-import { AppError } from "#/core/errors";
-import { messageFrom } from "#/core/errors";
-import { createAnyGlobMatcher } from "#/core/glob";
-import { err, ok } from "#/core/result";
-import { resolveTagTargetCandidates } from "#/tag/target-candidates";
-import { runTagOnTarget } from "#/tag/target-runner";
+import { AppError } from "#core/errors";
+import { messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
+import { filterSkippedCandidates } from "#tag/domain/skip-filter";
+import { extractDistinctVersions, summarizeVersions } from "#tag/domain/version-summary";
+import { resolveTagTargetCandidates } from "#tag/target/candidates";
+import { runTagOnTarget } from "#tag/target/runner";
 /**
- * Runs the tag sync across the selected targets and returns the aggregate result.
+ * Applies `@since` tags across the selected targets and returns the aggregate result.
  *
  * @since 0.3.16-canary.0
  */
-export async function runTagSync(fs, input) {
+export async function runTag(fs, input) {
     try {
         const tagConfig = input.config;
         const targetCandidates = await resolveTagTargetCandidates(fs, input.rootDir, input.targetPath);
         const { includedCandidates, skippedPackages } = filterSkippedCandidates(targetCandidates, input.skipPackages);
         const selectedTargets = includedCandidates.map((candidate) => resolveTargetSelection(fs, candidate, input.rootDir));
         const targetExecutionResults = await Promise.all(selectedTargets.map((resolvedTarget) => runOnResolvedTarget(fs, resolvedTarget, input.write, input.listener)));
-        const allFileResults = targetExecutionResults.flatMap((targetResult) => targetResult.result?.fileResults ?? []);
-        const filesScanned = targetExecutionResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesScanned ?? 0), 0);
-        const filesChanged = targetExecutionResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesChanged ?? 0), 0);
-        const taggedDeclarations = targetExecutionResults.reduce((sum, targetResult) => sum + (targetResult.result?.taggedDeclarations ?? 0), 0);
+        const allFileResults = [];
+        let filesScanned = 0;
+        let filesChanged = 0;
+        let taggedDeclarations = 0;
+        for (const targetResult of targetExecutionResults) {
+            const runResult = targetResult.result;
+            if (runResult === null) {
+                continue;
+            }
+            allFileResults.push(...runResult.fileResults);
+            filesScanned += runResult.filesScanned;
+            filesChanged += runResult.filesChanged;
+            taggedDeclarations += runResult.taggedDeclarations;
+        }
         const modifiedFiles = allFileResults.filter((entry) => entry.changed).map((entry) => entry.filePath);
         const hookError = input.write && modifiedFiles.length > 0
             ? await runTagOnAfterWriteHook(tagConfig?.onAfterWrite, modifiedFiles)
@@ -57,20 +68,6 @@ async function runTagOnAfterWriteHook(hook, modifiedFiles) {
         return `[tag] onAfterWrite hook failed: ${messageFrom(caughtHookError)}`;
     }
 }
-function summarizeVersions(distinctVersions) {
-    if (distinctVersions.size === 0) {
-        return "none";
-    }
-    if (distinctVersions.size > 1) {
-        return "mixed";
-    }
-    return distinctVersions.values().next().value ?? "none";
-}
-function extractDistinctVersions(targetResults) {
-    return new Set(targetResults
-        .map((targetResult) => targetResult.result?.version)
-        .filter((version) => typeof version === "string" && version.length > 0));
-}
 function chooseWorkspacePackageTargetPath(fs, candidate) {
     if (candidate.source !== "workspace-package") {
         return {
@@ -103,33 +100,6 @@ function resolveTargetSelection(fs, candidate, rootDir) {
         packageName: candidate.packageName,
     };
 }
-/**
- * Partition tag target candidates into those to tag and those to skip, matching
- * each candidate's package name against `skipPackages` as glob patterns.
- * Candidates without a package name (e.g. an explicit-target path) are never skipped.
- *
- * @since 0.5.0-canary.0
- */
-export function filterSkippedCandidates(targetCandidates, skipPackages) {
-    if (!skipPackages || skipPackages.length === 0) {
-        return {
-            includedCandidates: targetCandidates,
-            skippedPackages: [],
-        };
-    }
-    const isSkipped = createAnyGlobMatcher(skipPackages);
-    const includedCandidates = [];
-    const skippedPackages = [];
-    for (const candidate of targetCandidates) {
-        const packageName = candidate.packageName;
-        if (packageName && isSkipped(packageName)) {
-            skippedPackages.push(packageName);
-            continue;
-        }
-        includedCandidates.push(candidate);
-    }
-    return { includedCandidates, skippedPackages };
-}
 async function runOnResolvedTarget(fs, resolvedTarget, write, listener) {
     listener?.onTargetStarted(resolvedTarget);
     const absoluteTargetPath = path.resolve(resolvedTarget.targetPath);

package/dist/tag/target/candidates.d.ts

@@ -0,0 +1,8 @@
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { TagTargetCandidate } from "#tag/domain/types";
+/**
+ * Resolves the candidate targets for a tag run: the explicit target, or the discovered workspace packages.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function resolveTagTargetCandidates(fs: Filesystem, rootDir: string, explicitTarget: string | undefined): Promise<Array<TagTargetCandidate>>;

package/dist/tag/{target-candidates.js → target/candidates.js}

@@ -1,7 +1,7 @@
 import path from "node:path";
-import { z } from "zod";
-import { listWorkspacePackageDirectories } from "#/core/workspace/resolver";
-import { packageJsonFileName } from "#/core/workspace/well-known-files";
+import * as z from "zod";
+import { listWorkspacePackageDirectories } from "#core/workspace/resolver";
+import { packageJsonFileName } from "#core/workspace/well-known-files";
 const packageJsonNameSchema = z.looseObject({
     name: z.string().min(1).optional(),
 });

package/dist/tag/{resolve-target-path.d.ts → target/resolve-path.d.ts}

@@ -1,10 +1,10 @@
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Filesystem } from "#core/filesystem/filesystem";
 /**
  * Canonicalizes the user-provided target path, or returns `undefined` when none was given.
  *
  * @since 0.3.16-canary.0
  */
-export declare function resolveProvidedTagTargetPath(fs: FilesystemPort, args: {
+export declare function resolveProvidedTagTargetPath(fs: Filesystem, args: {
     readonly currentWorkingDirectory: string;
     readonly rawTarget: string | undefined;
 }): string | undefined;

package/dist/tag/target/runner.d.ts

@@ -0,0 +1,8 @@
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { TagRunOptions, TagRunResult } from "#tag/domain/types";
+/**
+ * Stamps `@since` tags across one target's TypeScript files and returns the run result.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function runTagOnTarget(fs: Filesystem, targetPath: string, opts: TagRunOptions): TagRunResult;

package/dist/tag/{target-runner.js → target/runner.js}

@@ -1,7 +1,7 @@
 import path from "node:path";
-import { walkTsxFiles } from "#/core/workspace/typescript-walk";
-import { TagSinceWriter } from "#/tag/since-writer";
-import { resolveNearestPackageVersion } from "#/tag/version-resolver";
+import { walkTsxFiles } from "#core/workspace/typescript-walk";
+import { TagSinceWriter } from "#tag/writer/since-writer";
+import { resolveNearestPackageVersion } from "#tag/writer/version-resolver";
 /**
  * Stamps `@since` tags across one target's TypeScript files and returns the run result.
  *

package/dist/tag/{since-writer.d.ts → writer/since-writer.d.ts}

@@ -1,5 +1,5 @@
-import type { FilesystemPort } from "#/core/filesystem/port";
-import type { TagFileResult } from "#/tag/domain/types";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { TagFileResult } from "#tag/domain/types";
 /**
  * The writer that adds missing `@since` tags to a file's exported declarations.
  *
@@ -8,7 +8,7 @@ import type { TagFileResult } from "#/tag/domain/types";
 export declare class TagSinceWriter {
     private readonly fs;
     private readonly sinceDocumentationTag;
-    constructor(fs: FilesystemPort);
+    constructor(fs: Filesystem);
     applySinceTagsToFile(filePath: string, version: string, write: boolean): TagFileResult;
     /**
      * The taggable declaration a top-level statement introduces, resolving the

package/dist/tag/{since-writer.js → writer/since-writer.js}

@@ -1,5 +1,5 @@
 import { parseSync } from "oxc-parser";
-import { applyEditsDescending, indentOfLineContaining } from "#/core/source-text-edit";
+import { applyEditsDescending, indentOfLineContaining } from "#core/source-text-edit";
 /**
  * Top-level statement kinds that carry a `@since` tag: function, class, interface,
  * type alias, enum, and variable declaration.

package/dist/tag/{version-resolver.d.ts → writer/version-resolver.d.ts}

@@ -1,7 +1,7 @@
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Filesystem } from "#core/filesystem/filesystem";
 /**
  * Returns the `version` of the nearest enclosing `package.json` above a target path.
  *
  * @since 0.3.16-canary.0
  */
-export declare function resolveNearestPackageVersion(fs: FilesystemPort, targetPath: string): string;
+export declare function resolveNearestPackageVersion(fs: Filesystem, targetPath: string): string;

package/dist/tag/{version-resolver.js → writer/version-resolver.js}

@@ -1,4 +1,4 @@
-import { findNearestPackageVersion } from "#/core/workspace/package-version";
+import { findNearestPackageVersion } from "#core/workspace/package-version";
 /**
  * Returns the `version` of the nearest enclosing `package.json` above a target path.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/cli",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Developer CLI for the Codefast monorepo (arrange, audit, mirror, pack-slim, tag)",
   "keywords": [
     "cli",
@@ -35,7 +35,7 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "imports": {
-    "#/*": {
+    "#*": {
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
     }
@@ -51,15 +51,23 @@
     "access": "public"
   },
   "dependencies": {
-    "@microsoft/tsdoc": "^0.16.0",
+    "@microsoft/tsdoc": "^0.17.0",
     "commander": "^15.0.0",
     "jiti": "^2.7.0",
-    "oxc-parser": "^0.148.0",
+    "oxc-parser": "^0.150.0",
     "picomatch": "^4.0.7",
-    "yaml": "^2.9.0",
-    "zod": "^4.5.4"
+    "yaml": "^2.9.1",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "typescript": "^7.0.2"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=22.12.0"
   }
 }

package/dist/arrange/analyze.d.ts

@@ -1,10 +0,0 @@
-import type { AnalyzeReport } from "#/arrange/domain/types";
-import { AppError } from "#/core/errors";
-import type { FilesystemPort } from "#/core/filesystem/port";
-import type { Result } from "#/core/result";
-/**
- * Scans a directory's arrange targets and returns the accumulated analyze report.
- *
- * @since 0.3.16-canary.0
- */
-export declare function analyzeDirectory(fs: FilesystemPort, analyzeRootPath: string): Result<AnalyzeReport, AppError>;