zinkee 0.1.44 → 0.1.45

package/src/completion/engine.ts

@@ -1,168 +0,0 @@
-import type { Command } from "commander";
-
-import { readConfigIfExists } from "../config.js";
-
-export interface CompletionRequest {
-  words: readonly string[];
-  cwordIndex: number;
-}
-
-export interface CompletionDeps {
-  configPath?: string;
-  readProfileNames?: (configPath: string | undefined) => readonly string[];
-}
-
-function readProfileNamesFromConfig(configPath: string | undefined): readonly string[] {
-  try {
-    const config = readConfigIfExists(configPath);
-    if (!config) {
-      return [];
-    }
-    return Object.keys(config.profiles).sort();
-  } catch {
-    return [];
-  }
-}
-
-function findSubcommand(command: Command, name: string): Command | undefined {
-  return command.commands.find((sub) => {
-    if (sub.name() === name) {
-      return true;
-    }
-    const aliases = sub.aliases();
-    return aliases.includes(name);
-  });
-}
-
-function collectFlagsThatTakeValues(root: Command): Set<string> {
-  const flags = new Set<string>();
-  const walk = (command: Command): void => {
-    for (const option of command.options) {
-      if (!option.required && !option.optional) {
-        continue;
-      }
-      if (option.long) {
-        flags.add(option.long);
-      }
-      if (option.short) {
-        flags.add(option.short);
-      }
-    }
-    for (const sub of command.commands) {
-      walk(sub);
-    }
-  };
-  walk(root);
-  return flags;
-}
-
-function descend(root: Command, words: readonly string[]): Command {
-  const flagsWithValues = collectFlagsThatTakeValues(root);
-  let current = root;
-  let index = 0;
-
-  while (index < words.length) {
-    const word = words[index]!;
-    if (word.startsWith("-")) {
-      const [flagPart] = word.split("=", 1);
-      if (flagPart && flagsWithValues.has(flagPart) && !word.includes("=")) {
-        index += 2;
-      } else {
-        index += 1;
-      }
-      continue;
-    }
-    const next = findSubcommand(current, word);
-    if (!next) {
-      break;
-    }
-    current = next;
-    index += 1;
-  }
-
-  return current;
-}
-
-function collectVisibleSubcommands(command: Command): readonly string[] {
-  const names: string[] = [];
-  for (const sub of command.commands) {
-    if (sub.name().startsWith("__")) {
-      continue;
-    }
-    names.push(sub.name());
-  }
-  return names;
-}
-
-function collectVisibleLongFlags(command: Command): readonly string[] {
-  const flags: string[] = [];
-  let current: Command | null = command;
-
-  while (current) {
-    for (const option of current.options) {
-      if (option.hidden || !option.long) {
-        continue;
-      }
-      if (!flags.includes(option.long)) {
-        flags.push(option.long);
-      }
-    }
-    current = current.parent;
-  }
-
-  if (!flags.includes("--help")) {
-    flags.push("--help");
-  }
-
-  return flags;
-}
-
-export function getCompletions(
-  program: Command,
-  request: CompletionRequest,
-  deps: CompletionDeps = {},
-): string[] {
-  const { words, cwordIndex } = request;
-  const safeIndex = Math.max(0, Math.min(cwordIndex, words.length));
-  const current = words[safeIndex] ?? "";
-  const prevToken = safeIndex > 0 ? words[safeIndex - 1] : undefined;
-  const readProfiles = deps.readProfileNames ?? readProfileNamesFromConfig;
-
-  if (prevToken === "--profile" || prevToken === "-p") {
-    try {
-      return readProfiles(deps.configPath)
-        .filter((name) => name.startsWith(current))
-        .slice()
-        .sort();
-    } catch {
-      return [];
-    }
-  }
-
-  const tokensBeforeCurrent = words.slice(1, safeIndex);
-  const command = descend(program, tokensBeforeCurrent);
-
-  const candidates = new Set<string>();
-
-  if (current.startsWith("-")) {
-    for (const flag of collectVisibleLongFlags(command)) {
-      if (flag.startsWith(current)) {
-        candidates.add(flag);
-      }
-    }
-    return [...candidates].sort();
-  }
-
-  for (const subcommand of collectVisibleSubcommands(command)) {
-    if (subcommand.startsWith(current)) {
-      candidates.add(subcommand);
-    }
-  }
-  for (const flag of collectVisibleLongFlags(command)) {
-    if (flag.startsWith(current)) {
-      candidates.add(flag);
-    }
-  }
-
-  return [...candidates].sort();
-}

package/src/completion/install.test.ts

@@ -1,179 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import {
-  CompletionShellError,
-  detectShell,
-  installCompletion,
-  parseShell,
-  resolveTarget,
-  type InstallEnvironment,
-} from "./install.js";
-
-const tempDirs: string[] = [];
-
-function createTempHome(): string {
-  const dir = mkdtempSync(join(tmpdir(), "zinkee-install-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function envFor(home: string, overrides: Partial<InstallEnvironment> = {}): InstallEnvironment {
-  return {
-    home,
-    platform: "linux",
-    shellEnv: "/bin/zsh",
-    ...overrides,
-  };
-}
-
-afterEach(() => {
-  while (tempDirs.length > 0) {
-    rmSync(tempDirs.pop()!, { force: true, recursive: true });
-  }
-});
-
-describe("detectShell", () => {
-  it("detects zsh from $SHELL", () => {
-    expect(detectShell({ home: "", platform: "linux", shellEnv: "/usr/bin/zsh" })).toBe("zsh");
-  });
-
-  it("detects bash from $SHELL", () => {
-    expect(detectShell({ home: "", platform: "linux", shellEnv: "/bin/bash" })).toBe("bash");
-  });
-
-  it("detects fish from $SHELL", () => {
-    expect(detectShell({ home: "", platform: "linux", shellEnv: "/usr/local/bin/fish" })).toBe(
-      "fish",
-    );
-  });
-
-  it("detects powershell from pwsh", () => {
-    expect(detectShell({ home: "", platform: "linux", shellEnv: "/usr/bin/pwsh" })).toBe(
-      "powershell",
-    );
-  });
-
-  it("falls back to powershell on win32 when $SHELL is unknown", () => {
-    expect(detectShell({ home: "", platform: "win32", shellEnv: undefined })).toBe("powershell");
-  });
-
-  it("throws when shell cannot be inferred", () => {
-    expect(() =>
-      detectShell({ home: "", platform: "linux", shellEnv: "/bin/csh" }),
-    ).toThrow(CompletionShellError);
-  });
-});
-
-describe("parseShell", () => {
-  it("normalizes pwsh to powershell", () => {
-    expect(parseShell("pwsh")).toBe("powershell");
-  });
-
-  it("rejects unsupported names", () => {
-    expect(() => parseShell("nu")).toThrow(CompletionShellError);
-  });
-});
-
-describe("resolveTarget", () => {
-  it("uses $PROFILE resolver for powershell", () => {
-    const home = createTempHome();
-    const target = resolveTarget(
-      "powershell",
-      envFor(home, {
-        platform: "win32",
-        resolvePowerShellProfile: () => join(home, "Documents", "PowerShell", "profile.ps1"),
-      }),
-    );
-    expect(target.scriptPath).toBe(join(home, "Documents", "PowerShell", "profile.ps1"));
-  });
-});
-
-describe("installCompletion", () => {
-  it("installs zsh completion and updates rc with idempotent block", () => {
-    const home = createTempHome();
-    writeFileSync(join(home, ".zshrc"), "# user content\n", "utf8");
-
-    const first = installCompletion("zsh", envFor(home));
-    expect(first.rcUpdated).toBe(true);
-    const rcAfter = readFileSync(join(home, ".zshrc"), "utf8");
-    expect(rcAfter).toContain("# >>> zinkee completion >>>");
-    expect(rcAfter).toContain(`fpath=("${join(home, ".zfunc")}" $fpath)`);
-    expect(rcAfter).toContain("autoload -Uz compinit && compinit");
-    expect(rcAfter).toContain("# user content");
-
-    const second = installCompletion("zsh", envFor(home));
-    expect(second.rcUpdated).toBe(false);
-    const rcSecond = readFileSync(join(home, ".zshrc"), "utf8");
-    const beginCount = (rcSecond.match(/# >>> zinkee completion >>>/g) ?? []).length;
-    expect(beginCount).toBe(1);
-  });
-
-  it("installs bash completion to ~/.bash_completions and sources it from .bashrc", () => {
-    const home = createTempHome();
-    const result = installCompletion("bash", envFor(home, { shellEnv: "/bin/bash" }));
-    expect(result.scriptPath).toBe(join(home, ".bash_completions", "zinkee.sh"));
-    expect(result.rcPath).toBe(join(home, ".bashrc"));
-
-    const rc = readFileSync(join(home, ".bashrc"), "utf8");
-    expect(rc).toContain(`source "${join(home, ".bash_completions", "zinkee.sh")}"`);
-
-    const script = readFileSync(result.scriptPath, "utf8");
-    expect(script).toContain("complete -o default -F _zinkee_completion zinkee");
-  });
-
-  it("installs fish completion without touching any rc file", () => {
-    const home = createTempHome();
-    const result = installCompletion("fish", envFor(home, { shellEnv: "/usr/bin/fish" }));
-    expect(result.scriptPath).toBe(
-      join(home, ".config", "fish", "completions", "zinkee.fish"),
-    );
-    expect(result.rcUpdated).toBe(false);
-
-    const script = readFileSync(result.scriptPath, "utf8");
-    expect(script).toContain("complete --no-files --command zinkee");
-  });
-
-  it("inlines powershell completion inside the resolved $PROFILE", () => {
-    const home = createTempHome();
-    const profilePath = join(home, "Documents", "PowerShell", "profile.ps1");
-    const result = installCompletion(
-      "powershell",
-      envFor(home, {
-        platform: "win32",
-        shellEnv: undefined,
-        resolvePowerShellProfile: () => profilePath,
-      }),
-    );
-
-    expect(result.scriptPath).toBe(profilePath);
-    const content = readFileSync(profilePath, "utf8");
-    expect(content).toContain("# >>> zinkee completion >>>");
-    expect(content).toContain("Register-ArgumentCompleter -Native -CommandName zinkee");
-  });
-
-  it("replaces an existing block instead of appending a new one", () => {
-    const home = createTempHome();
-    writeFileSync(
-      join(home, ".zshrc"),
-      [
-        "# top",
-        "# >>> zinkee completion >>>",
-        "stale-content",
-        "# <<< zinkee completion <<<",
-        "# bottom",
-      ].join("\n") + "\n",
-      "utf8",
-    );
-
-    installCompletion("zsh", envFor(home));
-    const rc = readFileSync(join(home, ".zshrc"), "utf8");
-    expect(rc).not.toContain("stale-content");
-    expect(rc).toContain("# top");
-    expect(rc).toContain("# bottom");
-    expect((rc.match(/# >>> zinkee completion >>>/g) ?? []).length).toBe(1);
-  });
-});

package/src/completion/install.ts

@@ -1,260 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, platform } from "node:os";
-import { basename, dirname, join } from "node:path";
-
-import { renderScript, type SupportedShell } from "./scripts.js";
-
-export const SUPPORTED_SHELLS: readonly SupportedShell[] = [
-  "bash",
-  "zsh",
-  "fish",
-  "powershell",
-];
-
-const BLOCK_BEGIN = "# >>> zinkee completion >>>";
-const BLOCK_END = "# <<< zinkee completion <<<";
-
-export interface InstallEnvironment {
-  home: string;
-  platform: NodeJS.Platform;
-  shellEnv: string | undefined;
-  resolvePowerShellProfile?: () => string | undefined;
-}
-
-export interface InstallTarget {
-  shell: SupportedShell;
-  scriptPath: string;
-  rcPath?: string;
-}
-
-export interface InstallResult {
-  shell: SupportedShell;
-  scriptPath: string;
-  rcPath?: string;
-  rcUpdated: boolean;
-}
-
-export class CompletionShellError extends Error {
-  override name = "CompletionShellError";
-}
-
-function defaultPowerShellProfile(env: InstallEnvironment): string | undefined {
-  for (const exe of ["pwsh", "powershell.exe"]) {
-    try {
-      const out = execFileSync(exe, ["-NoProfile", "-Command", "$PROFILE"], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      });
-      const path = out.trim();
-      if (path) {
-        return path;
-      }
-    } catch {
-      // try the next executable
-    }
-  }
-
-  if (env.platform === "win32") {
-    return join(env.home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
-  }
-  return join(env.home, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
-}
-
-export function detectShell(env: InstallEnvironment): SupportedShell {
-  const fromEnv = env.shellEnv;
-  if (fromEnv) {
-    const name = basename(fromEnv).toLowerCase().replace(/\.exe$/, "");
-    if (name === "bash") {
-      return "bash";
-    }
-    if (name === "zsh") {
-      return "zsh";
-    }
-    if (name === "fish") {
-      return "fish";
-    }
-    if (name === "pwsh" || name === "powershell") {
-      return "powershell";
-    }
-  }
-  if (env.platform === "win32") {
-    return "powershell";
-  }
-  throw new CompletionShellError(
-    `Could not detect a supported shell from $SHELL=${fromEnv ?? ""}. ` +
-      `Pass one of: ${SUPPORTED_SHELLS.join(", ")}.`,
-  );
-}
-
-export function parseShell(value: string): SupportedShell {
-  const normalized = value.toLowerCase();
-  if (
-    normalized === "bash" ||
-    normalized === "zsh" ||
-    normalized === "fish" ||
-    normalized === "powershell"
-  ) {
-    return normalized;
-  }
-  if (normalized === "pwsh") {
-    return "powershell";
-  }
-  throw new CompletionShellError(
-    `Unsupported shell "${value}". Supported: ${SUPPORTED_SHELLS.join(", ")}.`,
-  );
-}
-
-export function resolveTarget(
-  shell: SupportedShell,
-  env: InstallEnvironment,
-): InstallTarget {
-  switch (shell) {
-    case "bash":
-      return {
-        shell,
-        scriptPath: join(env.home, ".bash_completions", "zinkee.sh"),
-        rcPath: join(env.home, ".bashrc"),
-      };
-    case "zsh":
-      return {
-        shell,
-        scriptPath: join(env.home, ".zfunc", "_zinkee"),
-        rcPath: join(env.home, ".zshrc"),
-      };
-    case "fish":
-      return {
-        shell,
-        scriptPath: join(env.home, ".config", "fish", "completions", "zinkee.fish"),
-      };
-    case "powershell": {
-      const resolver = env.resolvePowerShellProfile ?? (() => defaultPowerShellProfile(env));
-      const profilePath = resolver();
-      if (!profilePath) {
-        throw new CompletionShellError(
-          "Could not resolve PowerShell $PROFILE path. Install PowerShell or use --show-completion.",
-        );
-      }
-      return {
-        shell,
-        scriptPath: profilePath,
-        rcPath: profilePath,
-      };
-    }
-  }
-}
-
-function buildRcSnippet(shell: SupportedShell, scriptPath: string): string {
-  switch (shell) {
-    case "bash":
-      return `source "${scriptPath}"`;
-    case "zsh":
-      return [
-        `fpath=("${dirname(scriptPath)}" $fpath)`,
-        "autoload -Uz compinit && compinit",
-      ].join("\n");
-    default:
-      return "";
-  }
-}
-
-function applyBlock(existing: string, block: string): string {
-  const wrapped = `${BLOCK_BEGIN}\n${block.trimEnd()}\n${BLOCK_END}\n`;
-  const blockPattern = new RegExp(
-    `${BLOCK_BEGIN.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${BLOCK_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`,
-    "m",
-  );
-  if (blockPattern.test(existing)) {
-    return existing.replace(blockPattern, wrapped);
-  }
-  const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
-  return `${existing}${separator}${wrapped}`;
-}
-
-function readFileOrEmpty(path: string): string {
-  try {
-    return readFileSync(path, "utf8");
-  } catch (error) {
-    if (
-      typeof error === "object" &&
-      error !== null &&
-      "code" in error &&
-      (error as NodeJS.ErrnoException).code === "ENOENT"
-    ) {
-      return "";
-    }
-    throw error;
-  }
-}
-
-function writeFileEnsuringDir(path: string, content: string): void {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, content, "utf8");
-}
-
-export function installCompletion(
-  shell: SupportedShell,
-  env: InstallEnvironment,
-): InstallResult {
-  const target = resolveTarget(shell, env);
-  const script = renderScript(shell);
-
-  if (shell === "powershell") {
-    const existing = readFileOrEmpty(target.scriptPath);
-    const updated = applyBlock(existing, script);
-    writeFileEnsuringDir(target.scriptPath, updated);
-    return {
-      shell,
-      scriptPath: target.scriptPath,
-      rcPath: target.scriptPath,
-      rcUpdated: true,
-    };
-  }
-
-  writeFileEnsuringDir(target.scriptPath, script);
-
-  if (!target.rcPath) {
-    return {
-      shell,
-      scriptPath: target.scriptPath,
-      rcUpdated: false,
-    };
-  }
-
-  const snippet = buildRcSnippet(shell, target.scriptPath);
-  if (!snippet) {
-    return {
-      shell,
-      scriptPath: target.scriptPath,
-      rcPath: target.rcPath,
-      rcUpdated: false,
-    };
-  }
-
-  const existingRc = readFileOrEmpty(target.rcPath);
-  const updatedRc = applyBlock(existingRc, snippet);
-  if (updatedRc !== existingRc) {
-    writeFileEnsuringDir(target.rcPath, updatedRc);
-    return {
-      shell,
-      scriptPath: target.scriptPath,
-      rcPath: target.rcPath,
-      rcUpdated: true,
-    };
-  }
-
-  return {
-    shell,
-    scriptPath: target.scriptPath,
-    rcPath: target.rcPath,
-    rcUpdated: false,
-  };
-}
-
-export function currentEnvironment(): InstallEnvironment {
-  return {
-    home: homedir(),
-    platform: platform(),
-    shellEnv: process.env.SHELL,
-  };
-}