outfitter 0.2.2 → 0.2.3

package/dist/shared/outfitter-9x1brcmq.js

@@ -0,0 +1,184 @@
+// @bun
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/template.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { dirname, extname, join } from "path";
+import { fileURLToPath } from "url";
+import { Result } from "@outfitter/contracts";
+var BINARY_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".webp",
+  ".bmp",
+  ".tiff",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".pdf",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".node",
+  ".wasm",
+  ".bin",
+  ".dat",
+  ".db",
+  ".sqlite",
+  ".sqlite3"
+]);
+function hasOutfitterPackage(dir) {
+  const packageJsonPath = join(dir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed.name === "outfitter";
+  } catch {
+    return false;
+  }
+}
+function getTemplatesDir() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0;i < 10; i++) {
+    const templatesPath = join(currentDir, "templates");
+    if (existsSync(templatesPath) && hasOutfitterPackage(currentDir)) {
+      return templatesPath;
+    }
+    currentDir = dirname(currentDir);
+  }
+  const fallback = join(process.cwd(), "apps/outfitter/templates");
+  if (existsSync(fallback)) {
+    return fallback;
+  }
+  return join(process.cwd(), "templates");
+}
+function getOutputFilename(templateFilename) {
+  return templateFilename.endsWith(".template") ? templateFilename.slice(0, -".template".length) : templateFilename;
+}
+function isBinaryFile(filename) {
+  return BINARY_EXTENSIONS.has(extname(filename).toLowerCase());
+}
+function replacePlaceholders(content, values) {
+  return content.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    if (Object.hasOwn(values, key)) {
+      return values[key];
+    }
+    return match;
+  });
+}
+function copyTemplateFiles(templateDir, targetDir, values, options, copyOptions) {
+  const allowOverwrite = copyOptions?.allowOverwrite ?? false;
+  const relativePrefix = copyOptions?.relativePrefix ?? "";
+  try {
+    if (!existsSync(targetDir)) {
+      if (options.collector) {
+        options.collector.add({
+          type: "dir-create",
+          path: targetDir
+        });
+      } else {
+        mkdirSync(targetDir, { recursive: true });
+      }
+    }
+    const entries = readdirSync(templateDir);
+    for (const entry of entries) {
+      const sourcePath = join(templateDir, entry);
+      const sourceStat = statSync(sourcePath);
+      const relativePath = relativePrefix ? `${relativePrefix}/${entry}` : entry;
+      if (copyOptions?.skipFilter?.(relativePath)) {
+        continue;
+      }
+      if (sourceStat.isDirectory()) {
+        const targetSubDir = join(targetDir, entry);
+        const nestedResult = copyTemplateFiles(sourcePath, targetSubDir, values, options, {
+          ...copyOptions,
+          relativePrefix: relativePath
+        });
+        if (nestedResult.isErr()) {
+          return nestedResult;
+        }
+        continue;
+      }
+      if (!sourceStat.isFile()) {
+        continue;
+      }
+      const outputFilename = getOutputFilename(entry);
+      const targetPath = join(targetDir, outputFilename);
+      const targetExists = existsSync(targetPath);
+      const canOverlay = allowOverwrite && (!targetExists || Boolean(copyOptions?.overwritablePaths?.has(targetPath)));
+      if (targetExists && !options.force && !canOverlay) {
+        if (options.collector) {
+          options.collector.add({
+            type: "file-skip",
+            path: targetPath,
+            reason: "exists"
+          });
+          continue;
+        }
+        return Result.err(new ScaffoldError(`File '${targetPath}' already exists. Use --force to overwrite.`));
+      }
+      if (options.collector) {
+        if (targetExists) {
+          options.collector.add({
+            type: "file-overwrite",
+            path: targetPath,
+            source: "template"
+          });
+        } else {
+          options.collector.add({
+            type: "file-create",
+            path: targetPath,
+            source: "template"
+          });
+        }
+        copyOptions?.writtenPaths?.add(targetPath);
+        continue;
+      }
+      if (isBinaryFile(outputFilename)) {
+        const buffer = readFileSync(sourcePath);
+        writeFileSync(targetPath, buffer);
+        copyOptions?.writtenPaths?.add(targetPath);
+        continue;
+      }
+      const content = readFileSync(sourcePath, "utf-8");
+      const processedContent = replacePlaceholders(content, values);
+      writeFileSync(targetPath, processedContent, "utf-8");
+      copyOptions?.writtenPaths?.add(targetPath);
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to copy template files: ${message}`));
+  }
+}
+
+export { getTemplatesDir, getOutputFilename, isBinaryFile, replacePlaceholders, copyTemplateFiles };

package/dist/shared/outfitter-a79xrm12.d.ts

@@ -0,0 +1,17 @@
+import { OutputMode } from "@outfitter/cli/types";
+type StructuredOutputMode = Extract<OutputMode, "json" | "jsonl">;
+/** Output modes resolvable from CLI flags and env vars. */
+type CliOutputMode = "human" | "json" | "jsonl";
+/**
+* Resolve output mode from CLI context (flags + env vars).
+*
+* Precedence: explicit flag > OUTFITTER_JSONL env > OUTFITTER_JSON env > "human"
+*
+* This function is pure -- no env var side effects.
+*/
+declare function resolveOutputModeFromContext(flags: Record<string, unknown>): CliOutputMode;
+/**
+* Resolve machine-readable output mode from explicit options first, then env.
+*/
+declare function resolveStructuredOutputMode(mode?: OutputMode): StructuredOutputMode | undefined;
+export { StructuredOutputMode, CliOutputMode, resolveOutputModeFromContext, resolveStructuredOutputMode };

package/dist/shared/outfitter-amc4jbs1.d.ts

@@ -0,0 +1,50 @@
+type Operation = {
+	readonly type: "file-create";
+	readonly path: string;
+	readonly source: "template" | "block" | "generated";
+} | {
+	readonly type: "file-overwrite";
+	readonly path: string;
+	readonly source: "template" | "block" | "generated";
+} | {
+	readonly type: "file-skip";
+	readonly path: string;
+	readonly reason: string;
+} | {
+	readonly type: "dir-create";
+	readonly path: string;
+} | {
+	readonly type: "dependency-add";
+	readonly name: string;
+	readonly version: string;
+	readonly section: "dependencies" | "devDependencies" | "peerDependencies";
+} | {
+	readonly type: "block-add";
+	readonly name: string;
+	readonly files: readonly string[];
+} | {
+	readonly type: "config-inject";
+	readonly target: string;
+	readonly description: string;
+} | {
+	readonly type: "git";
+	readonly action: "init" | "add-all" | "commit";
+	readonly cwd: string;
+	readonly message?: string | undefined;
+} | {
+	readonly type: "install";
+	readonly command: string;
+	readonly cwd: string;
+};
+declare class OperationCollector {
+	private readonly operations;
+	add(op: Operation): void;
+	getOperations(): readonly Operation[];
+	countByType(): Record<string, number>;
+	isEmpty(): boolean;
+	toJSON(): {
+		operations: readonly Operation[];
+		summary: Record<string, number>;
+	};
+}
+export { Operation, OperationCollector };

package/dist/shared/outfitter-ara3djt0.js

@@ -0,0 +1,73 @@
+// @bun
+import {
+  SHARED_DEV_DEPS,
+  SHARED_SCRIPTS
+} from "./outfitter-k112c427.js";
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { Result } from "@outfitter/contracts";
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function injectSharedConfig(targetDir) {
+  const packageJsonPath = join(targetDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return Result.ok(undefined);
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const existingDevDeps = parsed["devDependencies"] ?? {};
+    parsed["devDependencies"] = { ...SHARED_DEV_DEPS, ...existingDevDeps };
+    const existingScripts = parsed["scripts"] ?? {};
+    parsed["scripts"] = { ...SHARED_SCRIPTS, ...existingScripts };
+    writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to inject shared config: ${message}`));
+  }
+}
+function rewriteLocalDependencies(targetDir) {
+  const packageJsonPath = join(targetDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return Result.ok(undefined);
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    let updated = false;
+    for (const section of DEPENDENCY_SECTIONS) {
+      const deps = parsed[section];
+      if (!deps || typeof deps !== "object" || Array.isArray(deps)) {
+        continue;
+      }
+      const entries = deps;
+      for (const [name, version] of Object.entries(entries)) {
+        if (typeof version === "string" && name.startsWith("@outfitter/") && version !== "workspace:*") {
+          entries[name] = "workspace:*";
+          updated = true;
+        }
+      }
+    }
+    if (updated) {
+      writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to update local dependencies: ${message}`));
+  }
+}
+
+export { injectSharedConfig, rewriteLocalDependencies };

package/dist/shared/outfitter-avhm5z6w.js

@@ -0,0 +1,82 @@
+// @bun
+import {
+  getCreatePreset
+} from "./outfitter-vh4xgb93.js";
+import {
+  deriveBinName,
+  deriveProjectName
+} from "./outfitter-q9agarmb.js";
+
+// apps/outfitter/src/create/planner.ts
+import { Result, ValidationError } from "@outfitter/contracts";
+function derivePackageName(input) {
+  return (input.packageName ?? input.name).trim();
+}
+function planCreateProject(input) {
+  const packageName = derivePackageName(input);
+  if (packageName.length === 0) {
+    return Result.err(new ValidationError({
+      message: "Project name must not be empty",
+      field: "name"
+    }));
+  }
+  const targetDir = input.targetDir.trim();
+  if (targetDir.length === 0) {
+    return Result.err(new ValidationError({
+      message: "Target directory must not be empty",
+      field: "targetDir"
+    }));
+  }
+  if (packageName.startsWith("@") && !packageName.includes("/")) {
+    return Result.err(new ValidationError({
+      message: "Could not derive a project name from package name",
+      field: "packageName"
+    }));
+  }
+  const projectName = deriveProjectName(packageName);
+  if (projectName.length === 0) {
+    return Result.err(new ValidationError({
+      message: "Could not derive a project name from package name",
+      field: "packageName"
+    }));
+  }
+  const preset = getCreatePreset(input.preset);
+  if (!preset) {
+    return Result.err(new ValidationError({
+      message: `Unknown create preset '${input.preset}'`,
+      field: "preset"
+    }));
+  }
+  const includeTooling = input.includeTooling ?? true;
+  const defaultBlocks = includeTooling ? [...preset.defaultBlocks] : [];
+  const changes = [
+    {
+      type: "copy-template",
+      template: preset.template,
+      targetDir,
+      overlayBaseTemplate: true
+    },
+    { type: "inject-shared-config" }
+  ];
+  if (input.local) {
+    changes.push({ type: "rewrite-local-dependencies", mode: "workspace" });
+  }
+  if (defaultBlocks.length > 0) {
+    changes.push({ type: "add-blocks", blocks: defaultBlocks });
+  }
+  const plan = {
+    preset,
+    values: {
+      packageName,
+      projectName,
+      version: input.version?.trim() || "0.1.0",
+      description: input.description?.trim() || "A new project created with Outfitter",
+      binName: deriveBinName(projectName),
+      year: input.year ?? String(new Date().getFullYear())
+    },
+    changes
+  };
+  return Result.ok(plan);
+}
+
+export { planCreateProject };

package/dist/shared/outfitter-b5nd42y4.d.ts

@@ -0,0 +1,45 @@
+import { PostScaffoldResult } from "./outfitter-3weh61w7";
+import { OutputMode } from "@outfitter/cli/types";
+import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
+import { Command } from "commander";
+interface ScaffoldOptions {
+	readonly target: string;
+	readonly name?: string | undefined;
+	readonly force: boolean;
+	readonly skipInstall: boolean;
+	readonly dryRun: boolean;
+	readonly with?: string | undefined;
+	readonly noTooling?: boolean | undefined;
+	readonly local?: boolean | undefined;
+	readonly cwd: string;
+	readonly installTimeout?: number | undefined;
+}
+interface ScaffoldCommandResult {
+	readonly target: string;
+	readonly rootDir: string;
+	readonly targetDir: string;
+	readonly converted: boolean;
+	readonly movedExisting?: {
+		readonly from: string;
+		readonly to: string;
+		readonly name: string;
+	} | undefined;
+	readonly workspacePatternsUpdated: boolean;
+	readonly blocksAdded?: AddBlockResult | undefined;
+	readonly postScaffold: PostScaffoldResult;
+	readonly dryRunPlan?: {
+		readonly operations: readonly unknown[];
+		readonly summary: Record<string, number>;
+	} | undefined;
+}
+declare class ScaffoldCommandError extends Error {
+	readonly _tag: "ScaffoldCommandError";
+	constructor(message: string);
+}
+declare function runScaffold(options: ScaffoldOptions): Promise<Result<ScaffoldCommandResult, ScaffoldCommandError>>;
+declare function printScaffoldResults(result: ScaffoldCommandResult, options?: {
+	readonly mode?: OutputMode;
+}): Promise<void>;
+declare function scaffoldCommand(program: Command): void;
+export { ScaffoldOptions, ScaffoldCommandResult, ScaffoldCommandError, runScaffold, printScaffoldResults, scaffoldCommand };

package/dist/shared/outfitter-dd0btgec.d.ts

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+type DocsMdxMode = "strict" | "lossy";
+interface DocsBaseOptions {
+	readonly cwd?: string;
+	readonly workspaceRoot?: string;
+	readonly packagesDir?: string;
+	readonly outputDir?: string;
+	readonly excludedFilenames?: readonly string[];
+	readonly mdxMode?: DocsMdxMode;
+}
+interface ExecuteCheckCommandOptions extends DocsBaseOptions {}
+interface ExecuteSyncCommandOptions extends DocsBaseOptions {}
+type DocsExportTarget = "packages" | "llms" | "llms-full" | "all";
+interface ExecuteExportCommandOptions extends DocsBaseOptions {
+	readonly llmsFile?: string;
+	readonly llmsFullFile?: string;
+	readonly target?: DocsExportTarget | string;
+}
+interface DocsCommandIo {
+	readonly out: (line: string) => void;
+	readonly err: (line: string) => void;
+}
+interface CreateDocsCommandOptions {
+	readonly commandName?: string;
+	readonly io?: {
+		readonly out?: (line: string) => void;
+		readonly err?: (line: string) => void;
+	};
+}
+interface DocsModule {
+	createDocsCommand: (options?: CreateDocsCommandOptions) => Command;
+	executeCheckCommand: (options: ExecuteCheckCommandOptions, io: DocsCommandIo) => Promise<number>;
+	executeSyncCommand: (options: ExecuteSyncCommandOptions, io: DocsCommandIo) => Promise<number>;
+	executeExportCommand: (options: ExecuteExportCommandOptions, io: DocsCommandIo) => Promise<number>;
+}
+/**
+* Load docs command module with source-first resolution in monorepo development.
+*/
+declare function loadDocsModule(): Promise<DocsModule>;
+export { ExecuteCheckCommandOptions, ExecuteSyncCommandOptions, DocsExportTarget, ExecuteExportCommandOptions, DocsCommandIo, CreateDocsCommandOptions, loadDocsModule };

package/dist/shared/outfitter-e2zz5wv7.d.ts

@@ -0,0 +1,51 @@
+/**
+* Create planner types for kit-first project scaffolding.
+*
+* These types model preset intent separately from execution so future flows can
+* consume a deterministic plan before mutating the filesystem.
+*/
+type CreatePresetId = "basic" | "cli" | "daemon" | "mcp";
+interface CreatePresetDefinition {
+	readonly id: CreatePresetId;
+	readonly template: CreatePresetId;
+	readonly summary: string;
+	readonly defaultBlocks: readonly string[];
+}
+interface CreateProjectInput {
+	readonly name: string;
+	readonly targetDir: string;
+	readonly preset: CreatePresetId;
+	readonly packageName?: string;
+	readonly description?: string;
+	readonly version?: string;
+	readonly includeTooling?: boolean;
+	readonly local?: boolean;
+	readonly year?: string;
+}
+type CreatePlanChange = {
+	readonly type: "copy-template";
+	readonly template: string;
+	readonly targetDir: string;
+	readonly overlayBaseTemplate: boolean;
+} | {
+	readonly type: "inject-shared-config";
+} | {
+	readonly type: "rewrite-local-dependencies";
+	readonly mode: "workspace";
+} | {
+	readonly type: "add-blocks";
+	readonly blocks: readonly string[];
+};
+interface CreateProjectPlan {
+	readonly preset: CreatePresetDefinition;
+	readonly values: {
+		readonly packageName: string;
+		readonly projectName: string;
+		readonly version: string;
+		readonly description: string;
+		readonly binName: string;
+		readonly year: string;
+	};
+	readonly changes: readonly CreatePlanChange[];
+}
+export { CreatePresetId, CreatePresetDefinition, CreateProjectInput, CreatePlanChange, CreateProjectPlan };

package/dist/shared/outfitter-ehp18x1n.js

@@ -0,0 +1 @@
+// @bun