@anja.codes/vitakit 0.1.0 → 0.2.0

package/dist/cli.d.mts

@@ -1,45 +1,38 @@
-interface AddOptions {
-    /**
-     * Also scaffold `app/components/<Name>Section.vue`. On by default: a section
-     * without a component renders through the generic one, which is a fallback
-     * rather than a design.
-     */
-    component?: boolean;
+interface Io {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    /** Write to stdout; text is written as is, add `\n` yourself. */
+    out: (text: string) => void;
+    err: (text: string) => void;
+    /** Whether a person can answer questions: stdin and stdout are terminals. */
+    interactive: boolean;
+    /** Whether stdout is a terminal, for colour. */
+    tty: boolean;
+    /** Width of the terminal, when stdout is one. */
+    columns?: number;
+    /** Ask a question and return the answer; only called when `interactive`. */
+    ask: (question: string) => Promise<string>;
 }
-interface WrittenFile {
-    path: string;
-    /** Why it was written, for the command's output. */
-    note: string;
-}
-/**
- * Create what is missing for a section: the YAML file, the schema, optionally
- * a component. Existing files are never touched.
- */
-declare function addSection(id: string, rootDir: string, options?: AddOptions): Promise<WrittenFile[]>;
 
-interface EjectableItem {
-    /** Name to pass to `eject`, e.g. `VitaSection`, `talks.eta` or `teaching`. */
-    name: string;
-    kind: 'component' | 'template' | 'class' | 'schema' | 'style';
-    /** Absolute source path inside the package. */
-    source: string;
-    /** Destination relative to the project root. */
-    target: string;
-}
-/** Everything that can be copied into a project. */
-declare function listEjectable(): Promise<EjectableItem[]>;
-interface EjectResult {
-    item: EjectableItem;
-    /** Absolute path written. */
-    path: string;
-}
+declare function main(argv: string[], io?: Io): Promise<number>;
+
+type PackageManager = 'pnpm' | 'npm';
 /**
- * Copy a package default into the project, where it then wins by the normal
- * resolution rule. Never overwrites without `force`.
+ * The package manager that started this process, from the user agent npm and
+ * pnpm set for everything they run (`npm run`, `npx`, `pnpm <script>`,
+ * `pnpm exec`); anything but npm gets pnpm, the default, as in the creator.
+ * A binary run directly has no user agent; the project's lockfile decides.
  */
-declare function eject(name: string, rootDir: string, { force }?: {
-    force?: boolean | undefined;
-}): Promise<EjectResult>;
+declare function detectPackageManager(rootDir?: string, env?: NodeJS.ProcessEnv): PackageManager;
+interface Commands {
+    /** A script from package.json: `pnpm pdf cv`, `npm run pdf -- cv`. */
+    script: (name: string, args?: string) => string;
+    /** A binary of an installed package: `pnpm vitakit status`, `npx vitakit status`. */
+    bin: (name: string, args?: string) => string;
+}
+declare function commands(packageManager?: PackageManager): Commands;
+/** Lines of `command  # comment`, with the comments aligned. */
+declare function aligned(rows: [command: string, comment?: string][], indent?: string): string;
 
-export { addSection, eject, listEjectable };
-export type { AddOptions, EjectResult, EjectableItem, WrittenFile };
+export { aligned, commands, detectPackageManager, main };
+export type { Commands, Io, PackageManager };

package/dist/cli.mjs

@@ -1,225 +1,8 @@
-import { readFile, mkdir, writeFile, copyFile, readdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join, relative, basename } from 'node:path';
-import { s as schemas, o as resolveAsset } from './shared/vitakit.BxcnlFGP.mjs';
-import { b as bundledTexDir } from './shared/vitakit.BRhjqpAt.mjs';
-import { parse } from 'yaml';
+export { a as aligned, c as commands, d as detectPackageManager, m as main } from './shared/vitakit.CoWX2Z4R.mjs';
+import 'node:fs';
+import 'node:path';
+import './shared/vitakit.DQ6PmGoL.mjs';
 import 'node:url';
-import 'zod';
-import 'eta';
-import './shared/index.mjs';
-import './shared/vitakit.BlU-p01e.mjs';
-
-const DATE_LIKE = /^\d{4}(-\d{2}){0,2}$/;
-function pascalCase(id) {
-  return id.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function inferField(values, present, total) {
-  const optional = present < total ? ".optional()" : "";
-  const sample = values[0];
-  if (typeof sample === "boolean") return `z.boolean().default(false)`;
-  if (typeof sample === "number" && !DATE_LIKE.test(String(sample))) return `z.number()${optional}`;
-  if (values.every((value) => DATE_LIKE.test(String(value)))) return `dateRange${optional}`;
-  if (typeof sample === "object" && sample !== null && "from" in sample) return `dateRange${optional}`;
-  if (typeof sample === "string" && /^https?:\/\//.test(sample)) return `url${optional}`;
-  const strings = values.filter((value) => typeof value === "string");
-  const unique = [...new Set(strings)];
-  if (strings.length === values.length && unique.length > 1 && unique.length <= Math.max(2, values.length / 2) && unique.every((value) => /^[a-z][\w-]*$/.test(value))) {
-    return `z.enum([${unique.map((value) => `'${value}'`).join(", ")}])${optional}`;
-  }
-  if (typeof sample === "string") return `text${optional}`;
-  return `z.unknown()${optional}`;
-}
-function inferSchema(entries) {
-  const fields = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    for (const [key, value] of Object.entries(entry)) {
-      if (key === "visibility") continue;
-      if (!fields.has(key)) fields.set(key, []);
-      if (value !== void 0 && value !== null) fields.get(key).push(value);
-    }
-  }
-  const used = /* @__PURE__ */ new Set(["section"]);
-  const lines = [];
-  for (const [key, values] of fields) {
-    const present = entries.filter((entry) => entry[key] !== void 0).length;
-    let type = inferField(values, present, entries.length);
-    if (/^(title|headline)$/.test(key) && type.startsWith("text")) type = type.replace("text", "richText");
-    for (const primitive of ["dateRange", "richText", "text", "url", "z"]) {
-      if (new RegExp(`\\b${primitive}\\b`).test(type)) used.add(primitive);
-    }
-    lines.push(`  ${key}: ${type},`);
-  }
-  return { body: lines.join("\n"), imports: [...used].sort() };
-}
-const SAMPLE_YAML = (id) => `# ${id}: one entry per item, newest first is not required --
-# vitakit sorts by date for you. Edit the fields, then edit schemas/${id}.ts
-# to match.
-- date: 2025-03-14
-  title: An example entry
-  note: Replace this with something real.
-`;
-function schemaModule(id, body, imports, inferred) {
-  return [
-    `/**`,
-    ` * Shape of content/${id}.yml.`,
-    ` *`,
-    inferred ? ` * Drafted from the existing file: check the types, especially which fields
- * are optional and whether any should be an enum.` : ` * Edit freely: this file defines what content/${id}.yml may contain.`,
-    ` *`,
-    ` * \`section()\` adds \`visibility\` and validates a list of entries.`,
-    ` */`,
-    `import { ${imports.join(", ")} } from '@anja.codes/vitakit'`,
-    ``,
-    `export default section({`,
-    body || `  date: dateRange,
-  title: richText,`,
-    `})`,
-    ``
-  ].join("\n");
-}
-function componentModule(id) {
-  `${pascalCase(id)}Section`;
-  return `<script setup lang="ts">
-/**
- * How ${id} entries look. Yours to change: props in, markup out.
- *
- * \`useSection('${id}')\` returns validated, sorted entries; \`VitaEntry\`,
- * \`VitaDate\` and \`richHtml\` come from vitakit.
- */
-import { richHtml, type Entry } from '@anja.codes/vitakit/shared'
-
-const props = defineProps<{ entries?: Entry[], limit?: number }>()
-
-const items = computed(() => {
-  const source = props.entries ?? useSection('${id}')
-  return props.limit ? source.slice(0, props.limit) : source
-})
-<\/script>
-
-<template>
-  <ul v-if="items.length" class="vita-section">
-    <VitaEntry v-for="item in items" :key="item.id" :date="item.date as never">
-      <p class="vita-entry__title" v-html="richHtml(item.title)" />
-      <p v-if="typeof item.note === 'string'" class="vita-entry__note">
-        {{ item.note }}
-      </p>
-    </VitaEntry>
-  </ul>
-</template>
-`;
-}
-async function addSection(id, rootDir, options = {}) {
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)) {
-    throw new Error(`"${id}" must be lowercase kebab-case, e.g. research-stays`);
-  }
-  if (id in schemas) {
-    throw new Error(
-      `"${id}" is a built-in section: create content/${id}.yml and it works.
-  To change which fields it may contain, copy its schema into your project:
-      pnpm vitakit eject ${id}
-  and edit schemas/${id}.ts.`
-    );
-  }
-  const written = [];
-  const yamlPath = join(rootDir, "content", `${id}.yml`);
-  const schemaPath = join(rootDir, "schemas", `${id}.ts`);
-  let entries = [];
-  let inferred = false;
-  if (existsSync(yamlPath)) {
-    const parsed = parse(await readFile(yamlPath, "utf8"));
-    if (!Array.isArray(parsed)) throw new Error(`content/${id}.yml must contain a list of entries`);
-    entries = parsed.filter((entry) => typeof entry === "object" && entry !== null);
-    if (!entries.length) throw new Error(`content/${id}.yml has no entries to infer a schema from`);
-    inferred = true;
-  } else {
-    await mkdir(join(yamlPath, ".."), { recursive: true });
-    await writeFile(yamlPath, SAMPLE_YAML(id));
-    written.push({ path: yamlPath, note: "your data \u2014 edit this first" });
-    entries = [{ date: "2025-03-14", title: "An example entry", note: "Replace this." }];
-  }
-  if (existsSync(schemaPath)) {
-    throw new Error(`schemas/${id}.ts already exists; delete it first to regenerate`);
-  }
-  const { body, imports } = inferSchema(entries);
-  await mkdir(join(schemaPath, ".."), { recursive: true });
-  await writeFile(schemaPath, schemaModule(id, body, imports, inferred));
-  written.push({ path: schemaPath, note: inferred ? `drafted from content/${id}.yml` : "the shape of an entry" });
-  if (options.component !== false) {
-    const componentPath = join(rootDir, "app", "components", `${pascalCase(id)}Section.vue`);
-    if (!existsSync(componentPath)) {
-      await mkdir(join(componentPath, ".."), { recursive: true });
-      await writeFile(componentPath, componentModule(id));
-      written.push({ path: componentPath, note: "how the entries look" });
-    }
-  }
-  return written.map((file) => ({ ...file, path: relative(rootDir, file.path) }));
-}
-
-async function listEjectable() {
-  const items = [];
-  const componentsDir = resolveAsset("runtime/components");
-  for (const file of (await readdir(componentsDir)).filter((name) => name.endsWith(".vue")).sort()) {
-    items.push({
-      name: basename(file, ".vue"),
-      kind: "component",
-      source: join(componentsDir, file),
-      target: join("app", "components", file)
-    });
-  }
-  const templatesDir = join(bundledTexDir, "templates");
-  for (const file of (await readdir(templatesDir)).filter((name) => name.endsWith(".eta")).sort()) {
-    items.push({
-      name: file,
-      kind: "template",
-      source: join(templatesDir, file),
-      target: join("cv-tex", "templates", file)
-    });
-  }
-  const schemaDir = resolveAsset("schemas");
-  for (const file of (await readdir(schemaDir)).filter((name) => name.endsWith(".ts")).sort()) {
-    const id = basename(file, ".ts");
-    items.push({
-      name: id,
-      kind: "schema",
-      source: join(schemaDir, file),
-      target: join("schemas", file)
-    });
-  }
-  items.push({
-    name: "publications.csl",
-    kind: "style",
-    // The path of `defaultCslStyle`, without loading citation-js to get it.
-    source: join(resolveAsset("styles"), "vitakit-math.csl"),
-    target: join("content", "publications.csl")
-  });
-  items.push({
-    name: "vitakit-cv.cls",
-    kind: "class",
-    source: join(bundledTexDir, "vitakit-cv.cls"),
-    target: join("cv-tex", "vitakit-cv.cls")
-  });
-  return items;
-}
-async function eject(name, rootDir, { force = false } = {}) {
-  const items = await listEjectable();
-  const item = items.find((candidate) => candidate.name === name) ?? items.find((candidate) => candidate.name.toLowerCase() === name.toLowerCase());
-  if (!item) {
-    const known = items.map((candidate) => candidate.name).join(", ");
-    throw new Error(`unknown item "${name}". Available: ${known}`);
-  }
-  const path = join(rootDir, item.target);
-  if (existsSync(path) && !force) {
-    throw new Error(`${relative(rootDir, path)} already exists; pass --force to overwrite`);
-  }
-  await mkdir(join(path, ".."), { recursive: true });
-  if (item.kind === "schema") {
-    const source = await readFile(item.source, "utf8");
-    await writeFile(path, source.replace(/from '\.\.\/[\w-]+'/g, "from '@anja.codes/vitakit'"));
-  } else {
-    await copyFile(item.source, path);
-  }
-  return { item, path };
-}
-
-export { addSection, eject, listEjectable };
+import 'node:process';
+import 'node:util';
+import 'node:readline/promises';