outfitter 0.2.5 → 0.2.6

package/dist/shared/outfitter-ksyvwmb5.js

@@ -0,0 +1,191 @@
+// @bun
+// apps/outfitter/src/commands/demo.ts
+import { fileURLToPath } from "url";
+import { output } from "@outfitter/cli";
+import {
+  getPrimitiveIds,
+  isPrimitiveId,
+  renderAllDemos,
+  renderDemo
+} from "@outfitter/tui/demo";
+var EMBEDDED_DEMO_FLAG = "--__outfitter-embedded-demo";
+function isCommandNotFound(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return /ENOENT|not found|spawn/i.test(error.message);
+}
+async function tryRun(cmd) {
+  try {
+    const proc = Bun.spawn({
+      cmd,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    return await proc.exited;
+  } catch (error) {
+    if (isCommandNotFound(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+async function localDemoCmds(args) {
+  const localDistPath = fileURLToPath(new URL("../../../cli-demo/dist/cli.js", import.meta.url));
+  const localSrcPath = fileURLToPath(new URL("../../../cli-demo/src/cli.ts", import.meta.url));
+  const cmds = [];
+  if (await Bun.file(localDistPath).exists()) {
+    cmds.push([process.execPath, localDistPath, ...args]);
+  }
+  if (await Bun.file(localSrcPath).exists()) {
+    cmds.push([process.execPath, localSrcPath, ...args]);
+  }
+  return cmds;
+}
+function embeddedDemoCmd(args) {
+  return [
+    process.execPath,
+    fileURLToPath(import.meta.url),
+    EMBEDDED_DEMO_FLAG,
+    ...args
+  ];
+}
+function toCliArgs(options) {
+  const args = [];
+  if (options.section) {
+    args.push(options.section);
+  }
+  if (options.list) {
+    args.push("--list");
+  }
+  if (options.animate) {
+    args.push("--animate");
+  }
+  if (options.outputMode === "json") {
+    args.push("--json");
+  } else if (options.outputMode === "jsonl") {
+    args.push("--jsonl");
+  }
+  return args;
+}
+function toOutputMode(mode) {
+  return mode;
+}
+function renderListSections() {
+  const sections = getPrimitiveIds();
+  return [
+    "Available demo sections:",
+    ...sections.map((s) => `- ${s}`),
+    "- all"
+  ].join(`
+`);
+}
+function renderUnknownSection(section) {
+  const sections = getPrimitiveIds();
+  return [
+    `Unknown section: ${section}`,
+    "",
+    `Available sections: ${sections.join(", ")}, all`,
+    "",
+    "For app-specific sections (for example `errors`), run `outfitter-demo`."
+  ].join(`
+`);
+}
+function parseEmbeddedOptions(argv) {
+  let section;
+  let list = false;
+  let animate = false;
+  let outputMode = "human";
+  for (const arg of argv) {
+    if (arg === "--list" || arg === "-l") {
+      list = true;
+      continue;
+    }
+    if (arg === "--animate" || arg === "-a") {
+      animate = true;
+      continue;
+    }
+    if (arg === "--json") {
+      outputMode = "json";
+      continue;
+    }
+    if (arg === "--jsonl") {
+      outputMode = "jsonl";
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    if (section !== undefined) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+    section = arg;
+  }
+  return { section, list, animate, outputMode };
+}
+async function runEmbeddedDemo(options) {
+  const mode = toOutputMode(options.outputMode);
+  if (options.list) {
+    await output(renderListSections(), { mode });
+    return 0;
+  }
+  if (options.animate) {
+    await output(renderDemo("spinner"), { mode });
+    return 0;
+  }
+  if (options.section === undefined || options.section === "all") {
+    await output(renderAllDemos(), { mode });
+    return 0;
+  }
+  if (!isPrimitiveId(options.section)) {
+    await output(renderUnknownSection(options.section), { mode });
+    return 1;
+  }
+  await output(renderDemo(options.section), { mode });
+  return 0;
+}
+async function runEmbeddedFromArgv() {
+  if (process.argv[2] !== EMBEDDED_DEMO_FLAG) {
+    return;
+  }
+  const options = parseEmbeddedOptions(process.argv.slice(3));
+  const exitCode = await runEmbeddedDemo(options);
+  process.exit(exitCode);
+}
+if (import.meta.main) {
+  runEmbeddedFromArgv().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}
+`);
+    process.exit(1);
+  });
+}
+async function runDemo(options) {
+  const args = toCliArgs(options);
+  const commandCandidates = [
+    ["outfitter-demo", ...args],
+    ["cli-demo", ...args],
+    ...await localDemoCmds(args),
+    embeddedDemoCmd(args)
+  ];
+  for (const cmd of commandCandidates) {
+    const exitCode = await tryRun(cmd);
+    if (exitCode !== undefined) {
+      return { exitCode };
+    }
+  }
+  throw new Error([
+    "Demo functionality moved to the dedicated demo app.",
+    "",
+    "Run one of:",
+    "  outfitter-demo --help",
+    "  cli-demo --help",
+    "",
+    "In this monorepo, you can also run:",
+    "  bun run apps/cli-demo/src/cli.ts --help"
+  ].join(`
+`));
+}
+
+export { runDemo };

package/dist/shared/outfitter-mdt37hqm.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

package/dist/shared/outfitter-mtbpabf3.js

@@ -0,0 +1,91 @@
+// @bun
+import {
+  __require
+} from "./outfitter-mdt37hqm.js";
+
+// apps/outfitter/src/manifest.ts
+import { join } from "path";
+import {
+  InternalError,
+  Result,
+  ValidationError
+} from "@outfitter/contracts";
+import { z } from "zod";
+var OUTFITTER_DIR = ".outfitter";
+var MANIFEST_FILE = "manifest.json";
+var BlockEntrySchema = z.object({
+  installedFrom: z.string(),
+  installedAt: z.string().datetime()
+});
+var ManifestSchema = z.object({
+  version: z.literal(1),
+  blocks: z.record(z.string(), BlockEntrySchema)
+});
+function manifestPath(cwd) {
+  return join(cwd, OUTFITTER_DIR, MANIFEST_FILE);
+}
+async function readManifest(cwd) {
+  const path = manifestPath(cwd);
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    return Result.ok(null);
+  }
+  let raw;
+  try {
+    raw = await file.text();
+  } catch {
+    return Result.err(InternalError.create("Failed to read manifest file", { path }));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return Result.err(ValidationError.create("manifest", "Invalid JSON in manifest file"));
+  }
+  const validated = ManifestSchema.safeParse(parsed);
+  if (!validated.success) {
+    return Result.err(ValidationError.create("manifest", "Manifest file does not match expected schema"));
+  }
+  return Result.ok(validated.data);
+}
+async function writeManifest(cwd, manifest) {
+  const dirPath = join(cwd, OUTFITTER_DIR);
+  const path = join(dirPath, MANIFEST_FILE);
+  try {
+    const { mkdirSync, existsSync, statSync } = await import("fs");
+    if (existsSync(dirPath)) {
+      if (!statSync(dirPath).isDirectory()) {
+        return Result.err(ValidationError.create("manifest", ".outfitter exists but is not a directory"));
+      }
+    } else {
+      mkdirSync(dirPath, { recursive: true });
+    }
+    const content = JSON.stringify(manifest, null, "\t");
+    await Bun.write(path, `${content}
+`);
+    return Result.ok(undefined);
+  } catch {
+    return Result.err(InternalError.create("Failed to write manifest file", { path }));
+  }
+}
+async function stampBlock(cwd, blockName, toolingVersion) {
+  const readResult = await readManifest(cwd);
+  if (readResult.isErr()) {
+    return readResult;
+  }
+  const existing = readResult.value;
+  const manifest = existing ?? { version: 1, blocks: {} };
+  const updated = {
+    ...manifest,
+    blocks: {
+      ...manifest.blocks,
+      [blockName]: {
+        installedFrom: toolingVersion,
+        installedAt: new Date().toISOString()
+      }
+    }
+  };
+  return writeManifest(cwd, updated);
+}
+
+export { BlockEntrySchema, ManifestSchema, readManifest, writeManifest, stampBlock };