vize 0.303.0 → 0.310.0

package/src/init/report.ts

@@ -0,0 +1,136 @@
+import type { ProjectDetection } from "./detect.js";
+import { unreadOxlintConfig } from "./lint-target.js";
+import type { InitPlan } from "./plan.js";
+import { EDITOR_INTEGRATIONS } from "./templates.js";
+
+const PREFIX = "[vize init]";
+
+/**
+ * Detection summary, printed before any prompt.
+ *
+ * Users need to see what `init` concluded before they are asked to act on it;
+ * an unexpected line here is the cheapest place to catch a wrong root or a
+ * missing lockfile.
+ */
+export function renderDetection(detection: ProjectDetection): string {
+  const lines = [
+    `${PREFIX} detected in ${detection.root}:`,
+    `  framework:       ${describeFramework(detection)}`,
+    `  package manager: ${detection.packageManager ?? "none detected (defaulting to npm)"}`,
+    `  language:        ${detection.typescript ? "TypeScript" : "JavaScript"}${
+      detection.tsconfig === null ? " (no tsconfig.json)" : " (tsconfig.json)"
+    }`,
+    `  lint command:    ${detection.usesVitePlus ? "vp lint" : "oxlint"}`,
+    `  vize config:     ${detection.vizeConfig ?? "none"}`,
+    `  oxlint config:   ${describeOxlintConfig(detection)}`,
+  ];
+  return `${lines.join("\n")}\n`;
+}
+
+function describeFramework(detection: ProjectDetection): string {
+  if (detection.framework === "nuxt") {
+    return `Nuxt (${detection.nuxtConfig ?? "nuxt dependency, no nuxt.config"})`;
+  }
+  if (detection.framework === "vite") {
+    const configs = detection.viteConfigs.join(", ");
+    return detection.usesVitePlus ? `Vite+ (${configs})` : `Vite (${configs})`;
+  }
+  return "none (no vite.config or nuxt.config)";
+}
+
+function describeOxlintConfig(detection: ProjectDetection): string {
+  const unread = unreadOxlintConfig(detection);
+  if (unread !== null) {
+    return `${unread} — present but oxlint does not read this name (#3474)`;
+  }
+  return detection.oxlintConfig ?? "none";
+}
+
+/**
+ * The full plan.
+ *
+ * Printed before anything is written in both modes, so the wording is what the
+ * run is about to do, not what it has done. `--dry-run` differs only in stopping
+ * afterwards.
+ */
+export function renderPlan(plan: InitPlan, dryRun: boolean): string {
+  const verb = dryRun ? "would" : "will";
+  const lines: string[] = [`${PREFIX} plan:`];
+  for (const feature of plan.features) {
+    lines.push(`  ${feature.id.padEnd(9)} ${feature.outcome.padEnd(10)} ${feature.detail}`);
+  }
+  for (const filename of plan.createdFiles) {
+    lines.push(`${PREFIX} ${verb} create ${filename}`);
+  }
+  for (const filename of plan.updatedFiles) {
+    lines.push(`${PREFIX} ${verb} update ${filename}`);
+  }
+  if (plan.addedScripts.length > 0) {
+    lines.push(`${PREFIX} ${verb} add scripts: ${plan.addedScripts.join(", ")}`);
+  }
+  for (const command of plan.commands) {
+    lines.push(`${PREFIX} ${verb} run: ${command.command} ${command.args.join(" ")}`);
+  }
+  if (plan.createdFiles.length + plan.updatedFiles.length + plan.commands.length === 0) {
+    lines.push(`${PREFIX} nothing to do; the project is already configured`);
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+/**
+ * Snippets for anything `init` refused to edit.
+ *
+ * A blocked feature is deliberately loud. The alternative for the lint feature
+ * would be writing an Oxlint config the project's lint command never reads,
+ * which reports zero Vize diagnostics and exits 0 (#3389).
+ */
+export function renderBlocked(plan: InitPlan): string {
+  const blocked = plan.features.filter((feature) => feature.outcome === "blocked");
+  if (blocked.length === 0) {
+    return "";
+  }
+  const lines: string[] = [];
+  for (const feature of blocked) {
+    lines.push(`${PREFIX} ${feature.id}: NOT configured — ${feature.detail}`);
+    if (feature.snippet !== null) {
+      lines.push("", indent(feature.snippet), "");
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+export function renderEditors(): string {
+  const lines = [`${PREFIX} editor integrations shipped with Vize:`];
+  for (const integration of EDITOR_INTEGRATIONS) {
+    lines.push(`  ${integration}`);
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+/**
+ * Printed when the prompt ends without a confirmation.
+ *
+ * Covers both a declined confirmation and an input stream that closed
+ * mid-prompt. Saying so is what keeps a closed stdin from looking like a
+ * successful run that happened to change nothing.
+ */
+export function renderCancelled(): string {
+  return `${PREFIX} cancelled; nothing was written.\n`;
+}
+
+export function renderNonInteractiveRefusal(): string {
+  return (
+    `${PREFIX} stdin is not a TTY, so init will not prompt.\n` +
+    `${PREFIX} pass --yes with the features you want, for example:\n` +
+    `${PREFIX}   vize init --yes --lint --vite --fmt --typecheck --editor\n` +
+    `${PREFIX} or run with --dry-run to print the plan without writing.\n`
+  );
+}
+
+function indent(source: string): string {
+  return source
+    .split("\n")
+    .map((line) => (line === "" ? line : `    ${line}`))
+    .join("\n")
+    .trimEnd();
+}

package/src/init/select.ts

@@ -0,0 +1,153 @@
+import type { ProjectDetection } from "./detect.js";
+import { discoveredOxlintConfig, unreadOxlintConfig } from "./lint-target.js";
+
+export const FEATURE_IDS = ["lint", "bundler", "fmt", "typecheck", "editor"] as const;
+
+export type FeatureId = (typeof FEATURE_IDS)[number];
+
+export type FeatureSelection = Readonly<Record<FeatureId, boolean>>;
+
+export interface FeatureOffer {
+  readonly id: FeatureId;
+  /** Label shown in the prompt and in the plan. Reflects what detection found. */
+  readonly label: string;
+  /** False when the project cannot support the feature at all. */
+  readonly available: boolean;
+  /** True when the project already has this feature wired up. */
+  readonly configured: boolean;
+  /** Why the feature is unavailable or already configured. Empty when neither. */
+  readonly note: string;
+  readonly defaultSelected: boolean;
+}
+
+/**
+ * Turns detection into the five offers `init` presents.
+ *
+ * Already-configured features stay selected by default so a re-run is a no-op
+ * the user can confirm rather than a set of boxes they have to re-tick.
+ */
+export function offerFeatures(detection: ProjectDetection): readonly FeatureOffer[] {
+  return [
+    lintOffer(detection),
+    bundlerOffer(detection),
+    fmtOffer(detection),
+    typecheckOffer(detection),
+    editorOffer(detection),
+  ];
+}
+
+/** Selection implied by detection alone, used by `--yes` and as the prompt default. */
+export function defaultSelection(offers: readonly FeatureOffer[]): FeatureSelection {
+  const selection: Record<FeatureId, boolean> = {
+    lint: false,
+    bundler: false,
+    fmt: false,
+    typecheck: false,
+    editor: false,
+  };
+  for (const offer of offers) {
+    selection[offer.id] = offer.defaultSelected;
+  }
+  return selection;
+}
+
+function lintOffer(detection: ProjectDetection): FeatureOffer {
+  const configured = detection.usesVitePlus
+    ? detection.hasVitePlusLintBlock
+    : discoveredOxlintConfig(detection) !== null;
+  const unread = unreadOxlintConfig(detection);
+  const label = detection.usesVitePlus
+    ? "oxlint plugin (vp lint reads the `lint` block in the Vite config)"
+    : "oxlint plugin (the oxlint binary reads oxlint.config.ts)";
+  return {
+    id: "lint",
+    label,
+    available: true,
+    configured,
+    note: configured
+      ? "already configured"
+      : unread === null
+        ? ""
+        : `${unread} exists but oxlint never reads it (#3474)`,
+    defaultSelected: true,
+  };
+}
+
+function bundlerOffer(detection: ProjectDetection): FeatureOffer {
+  if (detection.framework === "nuxt") {
+    return {
+      id: "bundler",
+      label: "nuxt module (@vizejs/nuxt)",
+      available: detection.nuxtConfig !== null,
+      configured: detection.hasVizeNuxtModule,
+      note: detection.hasVizeNuxtModule
+        ? "already configured"
+        : detection.nuxtConfig === null
+          ? "no nuxt.config file to add @vizejs/nuxt to"
+          : "",
+      defaultSelected: detection.nuxtConfig !== null,
+    };
+  }
+  if (detection.framework === "vite") {
+    const single = detection.viteConfigs.length === 1;
+    return {
+      id: "bundler",
+      label: "vite plugin (@vizejs/vite-plugin)",
+      available: single,
+      configured: detection.hasVizeVitePlugin,
+      note: detection.hasVizeVitePlugin
+        ? "already configured"
+        : single
+          ? ""
+          : `several Vite configs (${detection.viteConfigs.join(", ")})`,
+      defaultSelected: single,
+    };
+  }
+  return {
+    id: "bundler",
+    label: "vite plugin or nuxt module",
+    available: false,
+    configured: false,
+    note: "no vite.config or nuxt.config found; the other features work without one",
+    defaultSelected: false,
+  };
+}
+
+function fmtOffer(detection: ProjectDetection): FeatureOffer {
+  const configured = detection.vizeConfig !== null && "vize:fmt" in detection.scripts;
+  return {
+    id: "fmt",
+    label: "fmt (vize fmt)",
+    available: true,
+    configured,
+    note: configured ? "already configured" : "",
+    defaultSelected: true,
+  };
+}
+
+function typecheckOffer(detection: ProjectDetection): FeatureOffer {
+  const configured = detection.vizeConfig !== null && "vize:check" in detection.scripts;
+  return {
+    id: "typecheck",
+    label: "typecheck (vize check)",
+    available: detection.tsconfig !== null,
+    configured,
+    note: configured
+      ? "already configured"
+      : detection.tsconfig === null
+        ? "needs a tsconfig.json"
+        : "",
+    defaultSelected: detection.tsconfig !== null,
+  };
+}
+
+function editorOffer(detection: ProjectDetection): FeatureOffer {
+  return {
+    id: "editor",
+    label: "editor extension (.vscode/extensions.json recommendation)",
+    available: true,
+    configured: detection.vscodeRecommendsVize,
+    note: detection.vscodeRecommendsVize ? "already recommended" : "",
+    defaultSelected: true,
+  };
+}

package/src/init/templates.ts

@@ -0,0 +1,175 @@
+/**
+ * Config sources `vize init` writes.
+ *
+ * Every Oxlint-facing template here is derived from one settings object so the
+ * `vp lint` block and the `oxlint` config can never describe different presets.
+ * See `lint-target.ts` for why writing the wrong one of the two is silent.
+ */
+
+/** Preset both Oxlint entry points run with. The bridge's own default. */
+export const INIT_LINT_PRESET = "general-recommended";
+
+/** `settings.vize.helpLevel` both Oxlint entry points run with. */
+export const INIT_LINT_HELP_LEVEL = "short";
+
+/** VS Code extension id published from `editors/vscode`. */
+export const VSCODE_EXTENSION_ID = "ubugeeei.vize";
+
+export interface VizeConfigFeatures {
+  readonly lint: boolean;
+  readonly fmt: boolean;
+  readonly typecheck: boolean;
+  readonly vite: boolean;
+}
+
+/**
+ * Builds `vize.config.ts` from the selected features.
+ *
+ * Only selected features contribute a block, so a project that asked for the
+ * formatter alone does not silently get a type checker it never opted into.
+ */
+export function renderVizeConfig(features: VizeConfigFeatures): string {
+  const blocks: string[] = [
+    `  compiler: {
+    templateSyntax: "standard",
+  },`,
+  ];
+  if (features.lint) {
+    blocks.push(`  linter: {
+    enabled: true,
+    preset: "${INIT_LINT_PRESET}",
+  },`);
+  }
+  if (features.fmt) {
+    blocks.push(`  formatter: {
+    singleAttributePerLine: false,
+    sortBlocks: true,
+  },`);
+  }
+  if (features.typecheck) {
+    blocks.push(`  typeChecker: {
+    enabled: true,
+    strict: true,
+  },`);
+  }
+  if (features.vite) {
+    blocks.push(`  vite: {
+    scanPatterns: ["src/**/*.vue"],
+  },`);
+  }
+  return `import { defineConfig } from "vize";
+
+export default defineConfig({
+${blocks.join("\n")}
+});
+`;
+}
+
+/**
+ * Config for the `oxlint` binary.
+ *
+ * `.oxlintrc.json` cannot import `configs.recommended`, and the bridge only runs
+ * `vize/*` rules that appear in `rules`, so a JSON config would need every rule
+ * id inlined and would rot on the next rule addition. `oxlint.config.ts` is
+ * Oxlint's TypeScript config format and is auto-discovered (verified against
+ * oxlint 1.64; `oxlint.config.mjs`, `.js`, `.cjs`, `.mts` and `.cts` are not --
+ * see #3474), so it is the only form that stays correct over time.
+ */
+export const INIT_OXLINT_CONFIG = `import { defineConfig } from "oxlint";
+import { configs } from "oxlint-plugin-vize";
+
+export default defineConfig({
+  plugins: ["vue"],
+  jsPlugins: ["oxlint-plugin-vize"],
+  settings: {
+    vize: {
+      preset: "${INIT_LINT_PRESET}",
+      helpLevel: "${INIT_LINT_HELP_LEVEL}",
+    },
+  },
+  rules: configs.recommended,
+});
+`;
+
+/** Import line the Vite+ `lint` block needs. */
+export const VITE_LINT_IMPORT =
+  'import { createVizeLintConfig } from "oxlint-plugin-vize";\n' as const;
+
+/**
+ * The Vite+ `lint` block, the only Oxlint configuration `vp lint` and `vp check`
+ * read.
+ *
+ * `createVizeLintConfig()` returns the whole block rather than fragments, which
+ * is what makes the `jsPlugins` entry impossible to omit. Hand-assembling the
+ * block is how a config ends up looking wired while reporting nothing.
+ */
+export const VITE_LINT_BLOCK = `  lint: createVizeLintConfig({
+    preset: "${INIT_LINT_PRESET}",
+    settings: {
+      helpLevel: "${INIT_LINT_HELP_LEVEL}",
+    },
+  }),
+`;
+
+/** Snippet printed when a Vite config has no `lint` block and cannot be edited safely. */
+export const VITE_LINT_SNIPPET = `import { createVizeLintConfig } from "oxlint-plugin-vize";
+
+export default defineConfig({
+${VITE_LINT_BLOCK}});
+`;
+
+/**
+ * Snippet printed when the Vite config already has a `lint` block.
+ *
+ * Spreading is the documented way to keep an existing block's other keys while
+ * still taking the whole Vize block, `jsPlugins` included.
+ */
+export const VITE_LINT_MERGE_SNIPPET = `import { createVizeLintConfig } from "oxlint-plugin-vize";
+
+export default defineConfig({
+  lint: {
+    ...createVizeLintConfig({
+      preset: "${INIT_LINT_PRESET}",
+      settings: {
+        helpLevel: "${INIT_LINT_HELP_LEVEL}",
+      },
+    }),
+    // keep your existing lint keys here
+  },
+});
+`;
+
+export const VITE_PLUGIN_IMPORT = 'import vize from "@vizejs/vite-plugin";\n' as const;
+
+export const VITE_PLUGIN_SNIPPET = `import vize from "@vizejs/vite-plugin";
+
+export default defineConfig({
+  plugins: [vize()],
+});
+`;
+
+export const NUXT_MODULE_SNIPPET = `export default defineNuxtConfig({
+  modules: ["@vizejs/nuxt"],
+});
+`;
+
+/**
+ * `.vscode/extensions.json` written when no file exists yet.
+ *
+ * Recommendations are chosen over `code --install-extension` because they are
+ * checked in, apply to the whole team, and change nothing on the machine that
+ * runs `init`.
+ */
+export function renderVscodeExtensions(indent: string | number): string {
+  return `${JSON.stringify({ recommendations: [VSCODE_EXTENSION_ID] }, null, indent)}\n`;
+}
+
+/** Editor integrations shipped from this repo, reported alongside the VS Code one. */
+export const EDITOR_INTEGRATIONS = [
+  "VS Code: ubugeeei.vize (recommended in .vscode/extensions.json)",
+  "Zed: tools/zed-vize",
+  "Neovim: tools/nvim-vize",
+  "Vim: tools/vim-vize",
+  "Helix: tools/helix-vize",
+  "Emacs: tools/emacs-vize",
+] as const;

package/src/init/top-level.ts

@@ -0,0 +1,143 @@
+/**
+ * Depth-aware lookup of a top-level key in a `defineConfig({ ... })` call.
+ *
+ * A plain regex cannot tell the config's own `plugins` key from the `plugins`
+ * key inside a `lint: { ... }` block, and picking the wrong one rewrites a part
+ * of the user's config they never asked to change. This scanner tracks bracket
+ * depth and skips strings, template literals and comments, so a key only matches
+ * at depth 0 of the config object.
+ *
+ * It is not a JavaScript parser and does not try to be: template-literal
+ * substitutions and regex literals are treated as ordinary text. Both make the
+ * scan give up or miss, which turns into a refusal to edit -- the safe direction.
+ */
+
+const IDENTIFIER = /^[$A-Z_a-z][$\w]*/u;
+const KEY_SEPARATOR = /^\s*:/u;
+
+export interface TopLevelKey {
+  /** Index of the first character of the key. */
+  readonly keyStart: number;
+  /** Index of the first character after the `:`. */
+  readonly valueStart: number;
+}
+
+/** Finds `key` at the top level of `callee({ ... })`, or `null`. */
+export function findTopLevelKey(source: string, callee: string, key: string): TopLevelKey | null {
+  const opening = new RegExp(`\\b${callee}\\s*\\(\\s*\\{`, "u").exec(source);
+  if (opening === null) {
+    return null;
+  }
+  let index = opening.index + opening[0].length;
+  let depth = 0;
+  while (index < source.length) {
+    const char = source[index]!;
+    const skipped = skipNonCode(source, index);
+    if (skipped !== index) {
+      index = skipped;
+      continue;
+    }
+    if (char === "{" || char === "[" || char === "(") {
+      depth += 1;
+      index += 1;
+      continue;
+    }
+    if (char === "}" || char === "]" || char === ")") {
+      if (depth === 0) {
+        // Closing brace of the config object itself: the key is not here.
+        return null;
+      }
+      depth -= 1;
+      index += 1;
+      continue;
+    }
+    const identifier = IDENTIFIER.exec(source.slice(index));
+    if (identifier === null) {
+      index += 1;
+      continue;
+    }
+    const separator = KEY_SEPARATOR.exec(source.slice(index + identifier[0].length));
+    if (depth === 0 && identifier[0] === key && separator !== null) {
+      return {
+        keyStart: index,
+        valueStart: index + identifier[0].length + separator[0].length,
+      };
+    }
+    index += identifier[0].length;
+  }
+  return null;
+}
+
+/** Number of `callee({` openings in the source. */
+export function countConfigCalls(source: string, callee: string): number {
+  return [...source.matchAll(new RegExp(`\\b${callee}\\s*\\(\\s*\\{`, "gu"))].length;
+}
+
+export interface ArrayValue {
+  /** Index just after the opening `[`. */
+  readonly contentStart: number;
+  /** True when the array holds nothing but whitespace. */
+  readonly empty: boolean;
+}
+
+/**
+ * Reads the array literal a top-level key is assigned to.
+ *
+ * Returns `null` when the value is not an array literal -- a spread from a
+ * variable, or a helper call -- because inserting into those would change what
+ * the config evaluates to.
+ */
+export function readTopLevelArray(source: string, callee: string, key: string): ArrayValue | null {
+  const found = findTopLevelKey(source, callee, key);
+  if (found === null) {
+    return null;
+  }
+  const rest = source.slice(found.valueStart);
+  const leading = /^\s*/u.exec(rest)![0];
+  if (rest[leading.length] !== "[") {
+    return null;
+  }
+  const contentStart = found.valueStart + leading.length + 1;
+  return { contentStart, empty: /^\s*\]/u.test(source.slice(contentStart)) };
+}
+
+/**
+ * Advances past a string, template literal or comment starting at `index`.
+ *
+ * Returns `index` unchanged when nothing at that position needs skipping.
+ */
+function skipNonCode(source: string, index: number): number {
+  const char = source[index]!;
+  if (char === '"' || char === "'" || char === "`") {
+    return skipQuoted(source, index, char);
+  }
+  if (char !== "/") {
+    return index;
+  }
+  const next = source[index + 1];
+  if (next === "/") {
+    const end = source.indexOf("\n", index);
+    return end === -1 ? source.length : end;
+  }
+  if (next === "*") {
+    const end = source.indexOf("*/", index + 2);
+    return end === -1 ? source.length : end + 2;
+  }
+  return index;
+}
+
+function skipQuoted(source: string, index: number, quote: string): number {
+  let cursor = index + 1;
+  while (cursor < source.length) {
+    const char = source[cursor]!;
+    if (char === "\\") {
+      cursor += 2;
+      continue;
+    }
+    if (char === quote) {
+      return cursor + 1;
+    }
+    cursor += 1;
+  }
+  return source.length;
+}