outfitter 0.2.1 → 0.2.3

package/dist/shared/outfitter-193jvzg4.d.ts

@@ -0,0 +1,5 @@
+import { EngineOptions, ScaffoldError } from "./outfitter-qfh36ddg";
+import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
+declare function addBlocks(targetDir: string, blocks: readonly string[], options: EngineOptions): Promise<Result<AddBlockResult, ScaffoldError>>;
+export { addBlocks };

package/dist/shared/outfitter-1dd0k853.js

@@ -0,0 +1,194 @@
+// @bun
+// apps/outfitter/src/targets/registry.ts
+import { NotFoundError, Result, ValidationError } from "@outfitter/contracts";
+var TARGET_ALIASES = new Map([
+  ["basic", "minimal"]
+]);
+var TARGET_REGISTRY = new Map([
+  [
+    "minimal",
+    {
+      id: "minimal",
+      description: "Minimal Bun + TypeScript project",
+      category: "library",
+      placement: "packages",
+      templateDir: "minimal",
+      defaultBlocks: ["scaffolding"],
+      status: "ready",
+      scope: "init-only"
+    }
+  ],
+  [
+    "cli",
+    {
+      id: "cli",
+      description: "CLI application with Outfitter command ergonomics",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "cli",
+      defaultBlocks: ["scaffolding"],
+      status: "ready",
+      scope: "both"
+    }
+  ],
+  [
+    "mcp",
+    {
+      id: "mcp",
+      description: "MCP server with typed tools and action registry",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "mcp",
+      defaultBlocks: ["scaffolding"],
+      status: "ready",
+      scope: "both"
+    }
+  ],
+  [
+    "daemon",
+    {
+      id: "daemon",
+      description: "Background daemon with control CLI",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "daemon",
+      defaultBlocks: ["scaffolding"],
+      status: "ready",
+      scope: "both"
+    }
+  ],
+  [
+    "api",
+    {
+      id: "api",
+      description: "HTTP API server (Hono)",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "api",
+      defaultBlocks: ["scaffolding"],
+      status: "stub",
+      scope: "both"
+    }
+  ],
+  [
+    "worker",
+    {
+      id: "worker",
+      description: "Background job worker",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "worker",
+      defaultBlocks: ["scaffolding"],
+      status: "stub",
+      scope: "both"
+    }
+  ],
+  [
+    "web",
+    {
+      id: "web",
+      description: "Web application (TanStack Start)",
+      category: "runnable",
+      placement: "apps",
+      templateDir: "web",
+      defaultBlocks: ["scaffolding"],
+      status: "stub",
+      scope: "both"
+    }
+  ],
+  [
+    "lib",
+    {
+      id: "lib",
+      description: "Shared library package",
+      category: "library",
+      placement: "packages",
+      templateDir: "lib",
+      defaultBlocks: ["scaffolding"],
+      status: "stub",
+      scope: "both"
+    }
+  ]
+]);
+var TARGET_IDS = [...TARGET_REGISTRY.keys()];
+var READY_TARGET_IDS = TARGET_IDS.filter((id) => TARGET_REGISTRY.get(id)?.status === "ready");
+var INIT_TARGET_IDS = TARGET_IDS.filter((id) => {
+  const target = TARGET_REGISTRY.get(id);
+  return target?.status === "ready" && target.scope !== "scaffold-only";
+});
+var SCAFFOLD_TARGET_IDS = TARGET_IDS.filter((id) => {
+  const target = TARGET_REGISTRY.get(id);
+  return target?.status === "ready" && target.scope !== "init-only";
+});
+function getTarget(id) {
+  const resolvedId = TARGET_ALIASES.get(id) ?? id;
+  const target = TARGET_REGISTRY.get(resolvedId);
+  if (!target) {
+    return Result.err(new NotFoundError({
+      message: `Unknown target '${id}'. Available targets: ${TARGET_IDS.join(", ")}`,
+      resourceType: "target",
+      resourceId: id
+    }));
+  }
+  return Result.ok(target);
+}
+function getReadyTarget(id) {
+  const targetResult = getTarget(id);
+  if (targetResult.isErr()) {
+    return targetResult;
+  }
+  const target = targetResult.value;
+  if (target.status === "stub") {
+    return Result.err(new ValidationError({
+      message: `Target '${id}' is not yet available. ` + "It is planned but the template has not been implemented. " + `Ready targets: ${READY_TARGET_IDS.join(", ")}`,
+      field: "target"
+    }));
+  }
+  return Result.ok(target);
+}
+function getInitTarget(id) {
+  const targetResult = getReadyTarget(id);
+  if (targetResult.isErr()) {
+    return targetResult;
+  }
+  const target = targetResult.value;
+  if (target.scope === "scaffold-only") {
+    return Result.err(new ValidationError({
+      message: `Target '${id}' cannot be used with init. Use 'outfitter scaffold ${id}' instead.`,
+      field: "target"
+    }));
+  }
+  return Result.ok(target);
+}
+function getScaffoldTarget(id) {
+  const targetResult = getReadyTarget(id);
+  if (targetResult.isErr()) {
+    return targetResult;
+  }
+  const target = targetResult.value;
+  if (target.scope === "init-only") {
+    return Result.err(new ValidationError({
+      message: `Target '${id}' cannot be scaffolded into an existing project. ` + `It is only available for new project creation via 'outfitter init'.`,
+      field: "target"
+    }));
+  }
+  return Result.ok(target);
+}
+function resolvePlacement(target) {
+  return target.placement;
+}
+function listTargets(filter) {
+  let targets = [...TARGET_REGISTRY.values()];
+  if (filter?.status) {
+    targets = targets.filter((target) => target.status === filter.status);
+  }
+  if (filter?.scope) {
+    targets = targets.filter((target) => target.scope === filter.scope);
+  }
+  if (filter?.category) {
+    targets = targets.filter((target) => target.category === filter.category);
+  }
+  return targets;
+}
+
+export { TARGET_REGISTRY, TARGET_IDS, READY_TARGET_IDS, INIT_TARGET_IDS, SCAFFOLD_TARGET_IDS, getTarget, getReadyTarget, getInitTarget, getScaffoldTarget, resolvePlacement, listTargets };

package/dist/shared/outfitter-1h7k8xxt.js

@@ -0,0 +1,29 @@
+// @bun
+// apps/outfitter/src/engine/collector.ts
+class OperationCollector {
+  operations = [];
+  add(op) {
+    this.operations.push(op);
+  }
+  getOperations() {
+    return this.operations;
+  }
+  countByType() {
+    const counts = {};
+    for (const op of this.operations) {
+      counts[op.type] = (counts[op.type] ?? 0) + 1;
+    }
+    return counts;
+  }
+  isEmpty() {
+    return this.operations.length === 0;
+  }
+  toJSON() {
+    return {
+      operations: this.operations,
+      summary: this.countByType()
+    };
+  }
+}
+
+export { OperationCollector };

package/dist/shared/outfitter-1qwpjt6w.js

@@ -0,0 +1,125 @@
+// @bun
+import {
+  copyTemplateFiles,
+  getTemplatesDir
+} from "./outfitter-9x1brcmq.js";
+import {
+  addBlocks
+} from "./outfitter-7cv5fg1m.js";
+import {
+  injectSharedConfig,
+  rewriteLocalDependencies
+} from "./outfitter-ara3djt0.js";
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/executor.ts
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { Result } from "@outfitter/contracts";
+async function executePlan(plan, options) {
+  try {
+    const templatesDir = getTemplatesDir();
+    let projectDir;
+    let blocksAdded;
+    for (const change of plan.changes) {
+      switch (change.type) {
+        case "copy-template": {
+          projectDir = change.targetDir;
+          if (!(existsSync(projectDir) || options.collector)) {
+            mkdirSync(projectDir, { recursive: true });
+          }
+          const templatePath = join(templatesDir, change.template);
+          if (!existsSync(templatePath)) {
+            return Result.err(new ScaffoldError(`Template '${change.template}' not found in ${templatesDir}`));
+          }
+          if (change.overlayBaseTemplate) {
+            const basePath = join(templatesDir, "_base");
+            if (existsSync(basePath)) {
+              const baseWrittenPaths = new Set;
+              const baseResult = copyTemplateFiles(basePath, projectDir, plan.values, options, {
+                writtenPaths: baseWrittenPaths
+              });
+              if (baseResult.isErr()) {
+                return baseResult;
+              }
+              const templateResult2 = copyTemplateFiles(templatePath, projectDir, plan.values, options, {
+                allowOverwrite: true,
+                overwritablePaths: baseWrittenPaths
+              });
+              if (templateResult2.isErr()) {
+                return templateResult2;
+              }
+              break;
+            }
+          }
+          const templateResult = copyTemplateFiles(templatePath, projectDir, plan.values, options);
+          if (templateResult.isErr()) {
+            return templateResult;
+          }
+          break;
+        }
+        case "inject-shared-config": {
+          if (!projectDir) {
+            break;
+          }
+          if (options.collector) {
+            options.collector.add({
+              type: "config-inject",
+              target: join(projectDir, "package.json"),
+              description: "Inject shared scripts/devDependencies"
+            });
+          } else {
+            const result = injectSharedConfig(projectDir);
+            if (result.isErr()) {
+              return result;
+            }
+          }
+          break;
+        }
+        case "rewrite-local-dependencies": {
+          if (!projectDir) {
+            break;
+          }
+          if (options.collector) {
+            options.collector.add({
+              type: "config-inject",
+              target: join(projectDir, "package.json"),
+              description: "Rewrite local @outfitter/* dependencies to workspace:*"
+            });
+          } else {
+            const result = rewriteLocalDependencies(projectDir);
+            if (result.isErr()) {
+              return result;
+            }
+          }
+          break;
+        }
+        case "add-blocks": {
+          if (!projectDir) {
+            break;
+          }
+          const result = await addBlocks(projectDir, change.blocks, options);
+          if (result.isErr()) {
+            return result;
+          }
+          blocksAdded = result.value;
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+    }
+    if (!projectDir) {
+      return Result.err(new ScaffoldError("Plan contains no copy-template step"));
+    }
+    return Result.ok({ projectDir, blocksAdded });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to execute scaffold plan: ${message}`));
+  }
+}
+
+export { executePlan };

package/dist/shared/outfitter-2ngep1h2.d.ts

@@ -0,0 +1,5 @@
+import { CreatePresetDefinition, CreatePresetId } from "./outfitter-e2zz5wv7";
+declare const CREATE_PRESETS: Readonly<Record<CreatePresetId, CreatePresetDefinition>>;
+declare const CREATE_PRESET_IDS: CreatePresetId[];
+declare function getCreatePreset(id: string): CreatePresetDefinition | undefined;
+export { CREATE_PRESETS, CREATE_PRESET_IDS, getCreatePreset };

package/dist/shared/outfitter-2np85etz.js

@@ -0,0 +1,95 @@
+// @bun
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/workspace.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+function buildWorkspaceRootPackageJson(workspaceName) {
+  const workspacePackage = {
+    name: workspaceName,
+    private: true,
+    version: "0.1.0",
+    workspaces: ["apps/*", "packages/*"],
+    scripts: {
+      build: "bun run --filter '*' build",
+      dev: "bun run --filter '*' dev",
+      test: "bun run --filter '*' test",
+      typecheck: "bun run --filter '*' typecheck",
+      lint: "bun run --filter '*' lint",
+      "lint:fix": "bun run --filter '*' lint:fix",
+      format: "bun run --filter '*' format"
+    }
+  };
+  return `${JSON.stringify(workspacePackage, null, 2)}
+`;
+}
+function scaffoldWorkspaceRoot(rootDir, workspaceName, force) {
+  const packageJsonPath = join(rootDir, "package.json");
+  if (existsSync(packageJsonPath) && !force) {
+    return Result.err(new ScaffoldError(`Directory '${rootDir}' already has a package.json. Use --force to overwrite.`));
+  }
+  try {
+    if (!existsSync(rootDir)) {
+      mkdirSync(rootDir, { recursive: true });
+    }
+    mkdirSync(join(rootDir, "apps"), { recursive: true });
+    mkdirSync(join(rootDir, "packages"), { recursive: true });
+    writeFileSync(packageJsonPath, buildWorkspaceRootPackageJson(workspaceName), "utf-8");
+    const gitignorePath = join(rootDir, ".gitignore");
+    if (force || !existsSync(gitignorePath)) {
+      writeFileSync(gitignorePath, `node_modules
+**/dist
+`, "utf-8");
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to scaffold workspace root: ${message}`));
+  }
+}
+function hasWorkspacesField(pkg) {
+  const workspaces = pkg.workspaces;
+  if (Array.isArray(workspaces) && workspaces.length > 0) {
+    return true;
+  }
+  if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
+    const packages = workspaces.packages;
+    if (Array.isArray(packages) && packages.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectWorkspaceRoot(cwd) {
+  let current = resolve(cwd);
+  const root = resolve("/");
+  while (true) {
+    if (existsSync(join(current, "pnpm-workspace.yaml"))) {
+      return Result.ok(current);
+    }
+    const pkgPath = join(current, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const raw = readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (hasWorkspacesField(pkg)) {
+          return Result.ok(current);
+        }
+      } catch {}
+    }
+    if (current === root) {
+      break;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return Result.ok(null);
+}
+
+export { buildWorkspaceRootPackageJson, scaffoldWorkspaceRoot, detectWorkspaceRoot };

package/dist/shared/outfitter-33w361tc.d.ts

@@ -0,0 +1,18 @@
+import { TargetCategory, TargetDefinition, TargetId, TargetScope, TargetStatus } from "./outfitter-k56rmt24";
+import { NotFoundError, Result, ValidationError } from "@outfitter/contracts";
+declare const TARGET_REGISTRY: ReadonlyMap<TargetId, TargetDefinition>;
+declare const TARGET_IDS: readonly TargetId[];
+declare const READY_TARGET_IDS: readonly TargetId[];
+declare const INIT_TARGET_IDS: readonly TargetId[];
+declare const SCAFFOLD_TARGET_IDS: readonly TargetId[];
+declare function getTarget(id: string): Result<TargetDefinition, NotFoundError>;
+declare function getReadyTarget(id: string): Result<TargetDefinition, NotFoundError | ValidationError>;
+declare function getInitTarget(id: string): Result<TargetDefinition, NotFoundError | ValidationError>;
+declare function getScaffoldTarget(id: string): Result<TargetDefinition, NotFoundError | ValidationError>;
+declare function resolvePlacement(target: TargetDefinition): "apps" | "packages";
+declare function listTargets(filter?: {
+	readonly status?: TargetStatus;
+	readonly scope?: TargetScope;
+	readonly category?: TargetCategory;
+}): readonly TargetDefinition[];
+export { TARGET_REGISTRY, TARGET_IDS, READY_TARGET_IDS, INIT_TARGET_IDS, SCAFFOLD_TARGET_IDS, getTarget, getReadyTarget, getInitTarget, getScaffoldTarget, resolvePlacement, listTargets };

package/dist/shared/outfitter-344t1r38.js

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

package/dist/shared/outfitter-3weh61w7.d.ts

@@ -0,0 +1,25 @@
+import { OperationCollector } from "./outfitter-amc4jbs1";
+import { Result } from "@outfitter/contracts";
+type ScaffoldOrigin = "init" | "scaffold";
+interface PostScaffoldOptions {
+	readonly rootDir: string;
+	readonly projectDir: string;
+	readonly origin: ScaffoldOrigin;
+	readonly target: string;
+	readonly structure: "single" | "workspace";
+	readonly skipInstall: boolean;
+	readonly skipGit: boolean;
+	readonly skipCommit: boolean;
+	readonly dryRun: boolean;
+	readonly installTimeoutMs: number;
+}
+interface PostScaffoldResult {
+	readonly installResult: "success" | "failed" | "skipped";
+	readonly installError?: string | undefined;
+	readonly gitInitResult: "success" | "failed" | "skipped" | "already-repo";
+	readonly gitCommitResult: "success" | "failed" | "skipped";
+	readonly gitError?: string | undefined;
+	readonly nextSteps: readonly string[];
+}
+declare function runPostScaffold(options: PostScaffoldOptions, collector?: OperationCollector): Promise<Result<PostScaffoldResult, never>>;
+export { PostScaffoldOptions, PostScaffoldResult, runPostScaffold };