pi-cc-extensions 0.1.1

package/extensions/ccstyle-powerline/bash-mode/completion.ts

@@ -0,0 +1,556 @@
+import { readdirSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import type { AutocompleteItem, AutocompleteProvider, AutocompleteSuggestions } from "@earendil-works/pi-tui";
+import { matchHistoryEntries, readGlobalShellHistory, readProjectHistory } from "./history.ts";
+import type { ExtendedCompletionItem, GhostSuggestion } from "./types.ts";
+
+interface TokenContext {
+  line: string;
+  cursorCol: number;
+  beforeCursor: string;
+  afterCursor: string;
+  token: string;
+  tokenStart: number;
+  tokenEnd: number;
+  tokenIndex: number;
+  previousTokens: string[];
+}
+
+export interface OneOffBashCommandContext {
+  prefix: string;
+  command: string;
+  offset: number;
+}
+
+const GIT_SUBCOMMANDS = [
+  "add", "bisect", "branch", "checkout", "cherry-pick", "clean", "clone", "commit", "diff", "fetch",
+  "grep", "init", "log", "merge", "mv", "pull", "push", "rebase", "reset", "restore", "revert", "rm",
+  "show", "stash", "status", "switch", "tag", "worktree",
+];
+
+function tokenizeBeforeCursor(text: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | null = null;
+  let escaped = false;
+
+  for (const char of text) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaped = true;
+      current += char;
+      continue;
+    }
+
+    if (quote) {
+      current += char;
+      if (char === quote) quote = null;
+      continue;
+    }
+
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+function getTokenContext(line: string, cursorCol: number): TokenContext {
+  const beforeCursor = line.slice(0, cursorCol);
+  const afterCursor = line.slice(cursorCol);
+  const tokens = tokenizeBeforeCursor(beforeCursor);
+
+  let tokenStart = 0;
+  for (let i = beforeCursor.length - 1; i >= 0; i -= 1) {
+    const char = beforeCursor[i];
+    if (char && /\s/.test(char)) {
+      tokenStart = i + 1;
+      break;
+    }
+  }
+
+  let tokenEnd = cursorCol;
+  for (let i = cursorCol; i < line.length; i += 1) {
+    const char = line[i];
+    if (char && /\s/.test(char)) break;
+    tokenEnd = i + 1;
+  }
+
+  return {
+    line,
+    cursorCol,
+    beforeCursor,
+    afterCursor,
+    token: line.slice(tokenStart, tokenEnd),
+    tokenStart,
+    tokenEnd,
+    tokenIndex: Math.max(0, tokens.length - 1),
+    previousTokens: tokens,
+  };
+}
+
+export function getOneOffBashCommandContext(line: string): OneOffBashCommandContext | null {
+  if (line.startsWith("!!")) {
+    return {
+      prefix: "!!",
+      command: line.slice(2),
+      offset: 2,
+    };
+  }
+
+  if (line.startsWith("!")) {
+    return {
+      prefix: "!",
+      command: line.slice(1),
+      offset: 1,
+    };
+  }
+
+  return null;
+}
+
+function supportsShouldTriggerFileCompletion(
+  provider: AutocompleteProvider,
+): provider is AutocompleteProvider & {
+  shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
+} {
+  return "shouldTriggerFileCompletion" in provider && typeof provider.shouldTriggerFileCompletion === "function";
+}
+
+function isExtendedCompletionItem(item: AutocompleteItem): item is ExtendedCompletionItem {
+  return "replacement" in item
+    && typeof item.replacement === "string"
+    && "startCol" in item
+    && typeof item.startCol === "number"
+    && "endCol" in item
+    && typeof item.endCol === "number";
+}
+
+function uniqueByReplacement(items: ExtendedCompletionItem[]): ExtendedCompletionItem[] {
+  const best = new Map<string, ExtendedCompletionItem>();
+  for (const item of items) {
+    const key = `${item.startCol}:${item.endCol}:${item.replacement}`;
+    const existing = best.get(key);
+    if (!existing || item.score > existing.score) {
+      best.set(key, item);
+    }
+  }
+  return [...best.values()].sort((a, b) => b.score - a.score || a.label.localeCompare(b.label));
+}
+
+function pathBase(token: string, cwd: string): { dir: string; prefix: string; displayPrefix: string } {
+  const expanded = token.startsWith("~/")
+    ? join(process.env.HOME || "", token.slice(2))
+    : token;
+
+  const hasSlash = expanded.includes("/");
+  if (!hasSlash) {
+    return { dir: cwd, prefix: expanded, displayPrefix: "" };
+  }
+
+  const baseDir = expanded.endsWith("/") ? expanded.slice(0, -1) : dirname(expanded);
+  const resolvedDir = isAbsolute(baseDir) ? baseDir : resolve(cwd, baseDir);
+  const prefix = expanded.endsWith("/") ? "" : basename(expanded);
+  const displayPrefix = token.endsWith("/") ? token : token.slice(0, Math.max(0, token.length - prefix.length));
+  return { dir: resolvedDir, prefix, displayPrefix };
+}
+
+function escapeShellPath(value: string): string {
+  return value.replace(/([\\\s"'`$&|;<>()[\]{}?!*])/g, "\\$1");
+}
+
+function getPathSuggestions(token: string, cwd: string): ExtendedCompletionItem[] {
+  if (!token) return [];
+  const { dir, prefix, displayPrefix } = pathBase(token, cwd);
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => prefix.length === 0 || entry.name.startsWith(prefix))
+      .slice(0, 100);
+
+    return entries.map((entry) => {
+      const suffix = entry.isDirectory() ? "/" : "";
+      const label = `${displayPrefix}${entry.name}${suffix}`;
+      const replacement = `${displayPrefix}${escapeShellPath(entry.name)}${suffix}`;
+      return {
+        value: replacement,
+        label,
+        replacement,
+        startCol: 0,
+        endCol: 0,
+        source: "path",
+        score: 40 + (entry.isDirectory() ? 4 : 0),
+      } satisfies ExtendedCompletionItem;
+    });
+  } catch {
+    // Missing or unreadable directories should only remove this completion source.
+    return [];
+  }
+}
+
+function runGit(args: string[], cwd: string): string[] {
+  try {
+    const result = spawnSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (result.status !== 0 || !result.stdout) return [];
+    return result.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+  } catch {
+    // Git-aware completions are optional and should not break the main completion flow.
+    return [];
+  }
+}
+
+function getGitSuggestions(ctx: TokenContext, cwd: string): ExtendedCompletionItem[] {
+  const tokens = ctx.previousTokens;
+  if (tokens[0] !== "git") return [];
+
+  if (ctx.tokenIndex <= 1) {
+    return GIT_SUBCOMMANDS
+      .filter((command) => command.startsWith(ctx.token))
+      .map((command) => ({
+        value: command,
+        label: command,
+        replacement: command,
+        startCol: 0,
+        endCol: 0,
+        source: "git",
+        score: 52,
+      }));
+  }
+
+  const subcommand = tokens[1] ?? "";
+  if (!["checkout", "switch", "merge", "rebase", "branch", "show", "diff"].includes(subcommand)) {
+    return [];
+  }
+
+  const refs = [
+    ...runGit(["branch", "--format=%(refname:short)"], cwd),
+    ...runGit(["tag", "--list"], cwd),
+  ];
+
+  return [...new Set(refs)]
+    .filter((ref) => ref.startsWith(ctx.token))
+    .slice(0, 100)
+    .map((ref) => ({
+      value: ref,
+      label: ref,
+      replacement: ref,
+      startCol: 0,
+      endCol: 0,
+      source: "git",
+      score: 50,
+    }));
+}
+
+function canUseHistorySuggestion(ctx: TokenContext): boolean {
+  return ctx.cursorCol === ctx.line.length && ctx.line.trim().length > 0;
+}
+
+function withRange(items: ExtendedCompletionItem[], startCol: number, endCol: number): ExtendedCompletionItem[] {
+  return items.map((item) => ({ ...item, startCol, endCol }));
+}
+
+function applyCompletionToLine(line: string, item: ExtendedCompletionItem): string {
+  return line.slice(0, item.startCol) + item.replacement + line.slice(item.endCol);
+}
+
+function commandHead(value: string): string {
+  return tokenizeBeforeCursor(value.trim())[0] ?? "";
+}
+
+function findNewestHistoryMatchForHead(entries: string[], prefix: string, head: string): string | null {
+  for (const rawEntry of entries) {
+    const entry = rawEntry.trim();
+    if (!entry || !entry.startsWith(prefix)) continue;
+    if (commandHead(entry) !== head) continue;
+    return entry;
+  }
+  return null;
+}
+
+function getCuratedCommandFallback(prefix: string): GhostSuggestion | null {
+  const trimmed = prefix.trim();
+  if (!trimmed) return null;
+
+  if ("cd".startsWith(trimmed)) {
+    return { value: "cd ..", source: "path" };
+  }
+
+  if ("git".startsWith(trimmed)) {
+    return { value: "git status", source: "git" };
+  }
+
+  return null;
+}
+
+function isLikelyGitCommandHead(prefix: string): boolean {
+  const trimmed = prefix.trim();
+  return trimmed.length >= 2 && "git".startsWith(trimmed);
+}
+
+function boostValidatedItemsFromGlobalHistory(
+  line: string,
+  items: ExtendedCompletionItem[],
+  globalHistoryMatches: string[],
+): ExtendedCompletionItem[] {
+  if (items.length === 0 || globalHistoryMatches.length === 0) {
+    return items;
+  }
+
+  const boosts = new Map<string, number>();
+  for (const [index, value] of globalHistoryMatches.entries()) {
+    boosts.set(value, Math.max(1, 4 - index));
+  }
+
+  return items.map((item) => {
+    const boost = boosts.get(applyCompletionToLine(line, item));
+    return boost ? { ...item, score: item.score + boost } : item;
+  });
+}
+
+export class BashCompletionEngine {
+  async getGhostSuggestion(line: string, cwd: string, shellPath: string, signal: AbortSignal): Promise<GhostSuggestion | null> {
+    const projectHistoryEntries = readProjectHistory(cwd);
+
+    if (line.trim().length === 0) {
+      const prefix = line;
+      const projectHistory = matchHistoryEntries(
+        projectHistoryEntries.map((entry) => entry.command),
+        line,
+        1,
+      );
+      if (projectHistory.length > 0) {
+        return { value: `${prefix}${projectHistory[0]!}`, source: "project-history" };
+      }
+
+      return null;
+    }
+
+    const ctx = getTokenContext(line, line.length);
+    if (!canUseHistorySuggestion(ctx)) return null;
+
+    const projectHistory = matchHistoryEntries(
+      projectHistoryEntries.map((entry) => entry.command),
+      line,
+      10,
+    );
+    if (projectHistory.length > 0) {
+      return { value: projectHistory[0]!, source: "project-history" };
+    }
+
+    if (ctx.tokenIndex === 0) {
+      return this.getCommandPositionGhostSuggestion(line, readGlobalShellHistory(shellPath));
+    }
+
+    const deterministic = this.getDeterministicInlineSuggestions(ctx, cwd);
+    const globalHistory = matchHistoryEntries(readGlobalShellHistory(shellPath), line, 5);
+    const ranked = boostValidatedItemsFromGlobalHistory(
+      line,
+      uniqueByReplacement(deterministic),
+      globalHistory,
+    );
+
+    for (const item of ranked) {
+      const value = this.buildInlineSuggestionValue(line, item);
+      if (value) {
+        return { value, source: item.source };
+      }
+    }
+
+    return null;
+  }
+
+  private getCommandPositionGhostSuggestion(
+    line: string,
+    globalHistoryEntries: string[],
+  ): GhostSuggestion | null {
+    if (isLikelyGitCommandHead(line)) {
+      const globalMatch = findNewestHistoryMatchForHead(globalHistoryEntries, line, "git");
+      if (globalMatch) {
+        return { value: globalMatch, source: "global-history" };
+      }
+    }
+
+    return getCuratedCommandFallback(line);
+  }
+
+  private getDeterministicInlineSuggestions(ctx: TokenContext, cwd: string): ExtendedCompletionItem[] {
+    const items: ExtendedCompletionItem[] = [];
+    items.push(...withRange(getGitSuggestions(ctx, cwd), ctx.tokenStart, ctx.tokenEnd));
+    items.push(...withRange(getPathSuggestions(ctx.token, cwd), ctx.tokenStart, ctx.tokenEnd));
+
+    return uniqueByReplacement(items);
+  }
+
+  private buildInlineSuggestionValue(line: string, item: ExtendedCompletionItem): string | null {
+    const value = applyCompletionToLine(line, item);
+    if (!value.startsWith(line) || value === line) {
+      return null;
+    }
+    return value;
+  }
+
+}
+
+export class BashAutocompleteProvider implements AutocompleteProvider {
+  getSuggestions(): AutocompleteSuggestions | null {
+    return null;
+  }
+
+  applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem): {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+  } {
+    if (!isExtendedCompletionItem(item)) {
+      throw new Error("Expected an extended completion item for bash autocomplete");
+    }
+
+    return applyExtendedCompletion(lines, cursorLine, item);
+  }
+
+  shouldTriggerFileCompletion(): boolean {
+    return false;
+  }
+}
+
+function applyExtendedCompletion(lines: string[], cursorLine: number, item: ExtendedCompletionItem): {
+  lines: string[];
+  cursorLine: number;
+  cursorCol: number;
+} {
+  const currentLine = lines[cursorLine] || "";
+  const startCol = Math.max(0, Math.min(item.startCol, currentLine.length));
+  const endCol = Math.max(startCol, Math.min(item.endCol, currentLine.length));
+  const nextLine = currentLine.slice(0, startCol) + item.replacement + currentLine.slice(endCol);
+  const nextLines = [...lines];
+  nextLines[cursorLine] = nextLine;
+  return {
+    lines: nextLines,
+    cursorLine,
+    cursorCol: startCol + item.replacement.length,
+  };
+}
+
+export class OneOffBashAutocompleteProvider implements AutocompleteProvider {
+  getSuggestions(): AutocompleteSuggestions | null {
+    return null;
+  }
+
+  applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem): {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+  } {
+    if (!isExtendedCompletionItem(item)) {
+      throw new Error("Expected an extended completion item for one-off bash autocomplete");
+    }
+
+    return applyExtendedCompletion(lines, cursorLine, item);
+  }
+
+  shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean {
+    const bang = cursorLine === 0 ? getOneOffBashCommandContext(lines[0] || "") : null;
+    return bang !== null && cursorCol >= bang.offset;
+  }
+}
+
+export class ModeAwareAutocompleteProvider implements AutocompleteProvider {
+  private readonly defaultProvider: AutocompleteProvider | undefined;
+  private readonly bashProvider: AutocompleteProvider;
+  private readonly oneOffBashProvider: AutocompleteProvider;
+  private readonly isBashModeActive: () => boolean;
+
+  constructor(
+    defaultProvider: AutocompleteProvider | undefined,
+    bashProvider: AutocompleteProvider,
+    oneOffBashProvider: AutocompleteProvider,
+    isBashModeActive: () => boolean,
+  ) {
+    this.defaultProvider = defaultProvider;
+    this.bashProvider = bashProvider;
+    this.oneOffBashProvider = oneOffBashProvider;
+    this.isBashModeActive = isBashModeActive;
+  }
+
+  getSuggestions(
+    lines: string[],
+    cursorLine: number,
+    cursorCol: number,
+    options: { signal: AbortSignal; force?: boolean },
+  ): AutocompleteSuggestions | null | Promise<AutocompleteSuggestions | null> {
+    if (this.isBashModeActive()) {
+      return this.bashProvider.getSuggestions(lines, cursorLine, cursorCol, options);
+    }
+
+    const shouldUseOneOffBash = supportsShouldTriggerFileCompletion(this.oneOffBashProvider)
+      && this.oneOffBashProvider.shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
+    if (shouldUseOneOffBash) {
+      return this.oneOffBashProvider.getSuggestions(lines, cursorLine, cursorCol, options);
+    }
+
+    return this.defaultProvider?.getSuggestions(lines, cursorLine, cursorCol, options) ?? null;
+  }
+
+  applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string) {
+    if (this.isBashModeActive()) {
+      return this.bashProvider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+    }
+
+    const shouldUseOneOffBash = supportsShouldTriggerFileCompletion(this.oneOffBashProvider)
+      && this.oneOffBashProvider.shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
+    if (shouldUseOneOffBash) {
+      return this.oneOffBashProvider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+    }
+
+    if (!this.defaultProvider) {
+      return { lines, cursorLine, cursorCol };
+    }
+    return this.defaultProvider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+  }
+
+  shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean {
+    if (this.isBashModeActive()) {
+      if (!supportsShouldTriggerFileCompletion(this.bashProvider)) {
+        return true;
+      }
+
+      return this.bashProvider.shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
+    }
+
+    const shouldUseOneOffBash = supportsShouldTriggerFileCompletion(this.oneOffBashProvider)
+      && this.oneOffBashProvider.shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
+    if (shouldUseOneOffBash) {
+      return true;
+    }
+
+    if (!this.defaultProvider || !supportsShouldTriggerFileCompletion(this.defaultProvider)) {
+      return false;
+    }
+
+    return this.defaultProvider.shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
+  }
+}