@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.0

package/tests/service/completion/CompletionServiceProvider.test.ts

@@ -0,0 +1,404 @@
+import { describe, expect, test } from "bun:test";
+import CompletionServiceProvider from "../../../src/service/completion/CompletionServiceProvider.ts";
+import DefaultCompletionService from "../../../src/service/completion/DefaultCompletionService.ts";
+import { COMPLETION_SERVICE_ID } from "../../../src/api/service/core/CompletionService.ts";
+import DefaultContext from "../../../src/runtime/DefaultContext.ts";
+import type CLIConfig from "../../../src/api/CLIConfig.ts";
+
+function getCLIConfig(): CLIConfig {
+  return { name: "testcli", description: "Test CLI", version: "1.0.0" };
+}
+
+describe("CompletionServiceProvider", () => {
+  test("has correct serviceId", () => {
+    const service = new DefaultCompletionService();
+    const provider = new CompletionServiceProvider(60, service);
+    expect(provider.serviceId).toEqual(COMPLETION_SERVICE_ID);
+  });
+
+  test("has correct servicePriority", () => {
+    const service = new DefaultCompletionService();
+    const provider = new CompletionServiceProvider(60, service);
+    expect(provider.servicePriority).toEqual(60);
+  });
+
+  test("getServiceInfo returns service and no commands", async () => {
+    const service = new DefaultCompletionService();
+    const provider = new CompletionServiceProvider(60, service);
+    const serviceInfo = await provider.getServiceInfo(getCLIConfig());
+
+    expect(serviceInfo.service).toBe(service);
+    expect(serviceInfo.commands.length).toEqual(0);
+  });
+
+  test("initService resolves when prompter service not available", async () => {
+    const service = new DefaultCompletionService();
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+    await expect(provider.initService(context)).resolves.toBeUndefined();
+  });
+
+  test("initService resolves when key-value service not available", async () => {
+    const service = new DefaultCompletionService();
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: true,
+        prompt: () => Promise.resolve({ name: "", value: false }),
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    await expect(provider.initService(context)).resolves.toBeUndefined();
+  });
+
+  test("initService skips when completion-status is 'installed'", async () => {
+    const service = new DefaultCompletionService();
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: true,
+        prompt: () => Promise.resolve({ name: "", value: false }),
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/key-value-service",
+      {
+        hasKey: (key: string) => Promise.resolve(key === "completion-status"),
+        getKey: () => Promise.resolve("installed"),
+        setKey: () => Promise.resolve(),
+        deleteKey: () => Promise.resolve(),
+      },
+    );
+    await expect(provider.initService(context)).resolves.toBeUndefined();
+  });
+
+  test("initService skips when completion-status is 'declined'", async () => {
+    const service = new DefaultCompletionService();
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: true,
+        prompt: () => Promise.resolve({ name: "", value: false }),
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/key-value-service",
+      {
+        hasKey: (key: string) => Promise.resolve(key === "completion-status"),
+        getKey: () => Promise.resolve("declined"),
+        setKey: () => Promise.resolve(),
+        deleteKey: () => Promise.resolve(),
+      },
+    );
+    await expect(provider.initService(context)).resolves.toBeUndefined();
+  });
+
+  test("initService skips when promptEnabled is false", async () => {
+    const service = new DefaultCompletionService();
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: false,
+        prompt: () => Promise.resolve({ name: "", value: false }),
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/key-value-service",
+      {
+        hasKey: () => Promise.resolve(false),
+        getKey: () => Promise.resolve(""),
+        setKey: () => Promise.resolve(),
+        deleteKey: () => Promise.resolve(),
+      },
+    );
+    await expect(provider.initService(context)).resolves.toBeUndefined();
+  });
+
+  test("initService skips when no supported shells detected", async () => {
+    const service = new DefaultCompletionService();
+    service.validateShellEnvironment = () => Promise.resolve(false);
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+
+    let promptCalled = false;
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: true,
+        prompt: () => {
+          promptCalled = true;
+          return Promise.resolve({ name: "", value: false });
+        },
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/key-value-service",
+      {
+        hasKey: () => Promise.resolve(false),
+        getKey: () => Promise.resolve(""),
+        setKey: () => Promise.resolve(),
+        deleteKey: () => Promise.resolve(),
+      },
+    );
+
+    await provider.initService(context);
+    expect(promptCalled).toBe(false);
+  });
+
+  test("initService stores 'declined' when user says no to completion", async () => {
+    const service = new DefaultCompletionService();
+    service.validateShellEnvironment = () => Promise.resolve(true);
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+
+    let storedKey = "";
+    let storedValue = "";
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: true,
+        prompt: () =>
+          Promise.resolve({ name: "enable-completion", value: false }),
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/key-value-service",
+      {
+        hasKey: () => Promise.resolve(false),
+        getKey: () => Promise.resolve(""),
+        setKey: (key: string, value: string) => {
+          storedKey = key;
+          storedValue = value;
+          return Promise.resolve();
+        },
+        deleteKey: () => Promise.resolve(),
+      },
+    );
+
+    await provider.initService(context);
+    expect(storedKey).toEqual("completion-status");
+    expect(storedValue).toEqual("declined");
+  });
+
+  test("initService skips shell prompt when only one shell detected", async () => {
+    const service = new DefaultCompletionService();
+    service.validateShellEnvironment = (shell) =>
+      Promise.resolve(shell === "bash");
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+
+    const storedEntries: Array<{ key: string; value: string }> = [];
+    const promptNames: string[] = [];
+
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: true,
+        prompt: (promptDef: { name: string }) => {
+          promptNames.push(promptDef.name);
+          return Promise.resolve({
+            name: promptDef.name,
+            value: true,
+          });
+        },
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/key-value-service",
+      {
+        hasKey: () => Promise.resolve(false),
+        getKey: () => Promise.resolve(""),
+        setKey: (key: string, value: string) => {
+          storedEntries.push({ key, value });
+          return Promise.resolve();
+        },
+        deleteKey: () => Promise.resolve(),
+      },
+    );
+
+    let infoMessage = "";
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/printer-service",
+      {
+        info: (msg: string) => {
+          infoMessage = msg;
+          return Promise.resolve();
+        },
+        warn: () => Promise.resolve(),
+        error: () => Promise.resolve(),
+        print: () => Promise.resolve(),
+      },
+    );
+
+    await provider.initService(context);
+
+    expect(promptNames).toEqual(["enable-completion"]);
+    const statusEntry = storedEntries.find(
+      (e) => e.key === "completion-status",
+    );
+    expect(statusEntry).toBeDefined();
+    expect(statusEntry!.value).toEqual("installed");
+    expect(infoMessage).toContain("Shell completion installed for bash");
+  });
+
+  test("initService shows shell prompt with default when multiple shells detected", async () => {
+    const service = new DefaultCompletionService();
+    service.validateShellEnvironment = (shell) =>
+      Promise.resolve(shell === "bash" || shell === "zsh");
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+
+    const storedEntries: Array<{ key: string; value: string }> = [];
+    const promptResponses = new Map<string, unknown>();
+    promptResponses.set("enable-completion", true);
+    promptResponses.set("shell-type", "zsh");
+
+    let shellPromptDefault: unknown;
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: true,
+        prompt: (promptDef: {
+          name: string;
+          defaultOption?: { returnedValue: unknown };
+        }) => {
+          if (promptDef.name === "shell-type") {
+            shellPromptDefault = promptDef.defaultOption;
+          }
+          return Promise.resolve({
+            name: promptDef.name,
+            value: promptResponses.get(promptDef.name),
+          });
+        },
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/key-value-service",
+      {
+        hasKey: () => Promise.resolve(false),
+        getKey: () => Promise.resolve(""),
+        setKey: (key: string, value: string) => {
+          storedEntries.push({ key, value });
+          return Promise.resolve();
+        },
+        deleteKey: () => Promise.resolve(),
+      },
+    );
+
+    let infoMessage = "";
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/printer-service",
+      {
+        info: (msg: string) => {
+          infoMessage = msg;
+          return Promise.resolve();
+        },
+        warn: () => Promise.resolve(),
+        error: () => Promise.resolve(),
+        print: () => Promise.resolve(),
+      },
+    );
+
+    await provider.initService(context);
+
+    expect(shellPromptDefault).toEqual({
+      displayValue: "bash",
+      returnedValue: "bash",
+    });
+    const statusEntry = storedEntries.find(
+      (e) => e.key === "completion-status",
+    );
+    expect(statusEntry).toBeDefined();
+    expect(statusEntry!.value).toEqual("installed");
+    expect(infoMessage).toContain("Shell completion installed for zsh");
+  });
+
+  test("initService shows error when installation fails", async () => {
+    const service = new DefaultCompletionService();
+    service.validateShellEnvironment = () => Promise.resolve(true);
+    const originalGetConfigPath = service.getDefaultConfigPath.bind(service);
+    service.getDefaultConfigPath = () => {
+      throw new Error("test error");
+    };
+
+    const provider = new CompletionServiceProvider(60, service);
+    await provider.getServiceInfo(getCLIConfig());
+
+    const context = new DefaultContext(getCLIConfig());
+
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/prompter-service",
+      {
+        promptEnabled: true,
+        prompt: (promptDef: { name: string }) =>
+          Promise.resolve({
+            name: promptDef.name,
+            value: promptDef.name === "enable-completion" ? true : "bash",
+          }),
+        promptAll: () => Promise.resolve([]),
+      },
+    );
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/key-value-service",
+      {
+        hasKey: () => Promise.resolve(false),
+        getKey: () => Promise.resolve(""),
+        setKey: () => Promise.resolve(),
+        deleteKey: () => Promise.resolve(),
+      },
+    );
+
+    let errorMessage = "";
+    context.addServiceInstance(
+      "@flowscripter/dynamic-cli-framework/printer-service",
+      {
+        info: () => Promise.resolve(),
+        warn: () => Promise.resolve(),
+        error: (msg: string) => {
+          errorMessage = msg;
+          return Promise.resolve();
+        },
+        print: () => Promise.resolve(),
+      },
+    );
+
+    await provider.initService(context);
+    expect(errorMessage).toContain("Failed to install completion");
+    expect(errorMessage).toContain("test error");
+
+    service.getDefaultConfigPath = originalGetConfigPath;
+  });
+});

package/tests/service/completion/DefaultCompletionService.test.ts

@@ -0,0 +1,278 @@
+import path from "node:path";
+import { describe, expect, test } from "bun:test";
+import DefaultCompletionService from "../../../src/service/completion/DefaultCompletionService.ts";
+import DefaultCommandRegistry from "../../../src/runtime/registry/DefaultCommandRegistry.ts";
+import { ShellType } from "../../../src/api/service/core/CompletionService.ts";
+import type SubCommand from "../../../src/api/command/SubCommand.ts";
+import type GroupCommand from "../../../src/api/command/GroupCommand.ts";
+import type GlobalCommand from "../../../src/api/command/GlobalCommand.ts";
+import type GlobalModifierCommand from "../../../src/api/command/GlobalModifierCommand.ts";
+import { ArgumentValueTypeName } from "../../../src/api/argument/ArgumentValueTypes.ts";
+import type Context from "../../../src/api/Context.ts";
+
+function makeSubCommand(
+  name: string,
+  description = "",
+  options: SubCommand["options"] = [],
+  positionals: SubCommand["positionals"] = [],
+): SubCommand {
+  return {
+    name,
+    description,
+    enableConfiguration: false,
+    options,
+    positionals,
+    execute: () => Promise.resolve(),
+  };
+}
+
+function makeGroupCommand(
+  name: string,
+  description: string,
+  members: SubCommand[],
+): GroupCommand {
+  return {
+    name,
+    description,
+    enableConfiguration: false,
+    memberSubCommands: members,
+    execute: (_context: Context) => Promise.resolve(),
+  };
+}
+
+function makeGlobalCommand(
+  name: string,
+  description: string,
+): GlobalCommand {
+  return {
+    name,
+    description,
+    enableConfiguration: false,
+    argument: { type: ArgumentValueTypeName.BOOLEAN },
+    execute: () => Promise.resolve(),
+  };
+}
+
+function makeGlobalModifierCommand(
+  name: string,
+  description: string,
+): GlobalModifierCommand {
+  return {
+    name,
+    description,
+    enableConfiguration: false,
+    argument: { type: ArgumentValueTypeName.BOOLEAN },
+    executePriority: 0,
+    execute: () => Promise.resolve(),
+  };
+}
+
+describe("DefaultCompletionService", () => {
+  function createService(
+    commands: Array<
+      SubCommand | GroupCommand | GlobalCommand | GlobalModifierCommand
+    >,
+  ): DefaultCompletionService {
+    const service = new DefaultCompletionService();
+    const registry = new DefaultCommandRegistry(commands);
+    service.setCommandRegistry(registry);
+    return service;
+  }
+
+  test("returns empty completions if no registry set", async () => {
+    const service = new DefaultCompletionService();
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli ",
+      6,
+    );
+    expect(result).toEqual([]);
+  });
+
+  test("completes command names from prefix", async () => {
+    const service = createService([
+      makeSubCommand("help", "Display help"),
+      makeSubCommand("history", "Show history"),
+      makeSubCommand("run", "Run something"),
+    ]);
+
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli h",
+      7,
+    );
+    expect(result.length).toEqual(2);
+    expect(result.map((r) => r.value)).toContain("help");
+    expect(result.map((r) => r.value)).toContain("history");
+  });
+
+  test("completes all commands when no prefix", async () => {
+    const service = createService([
+      makeSubCommand("help", "Display help"),
+      makeSubCommand("run", "Run something"),
+    ]);
+
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli ",
+      6,
+    );
+    expect(result.map((r) => r.value)).toContain("help");
+    expect(result.map((r) => r.value)).toContain("run");
+  });
+
+  test("completes group:member joined names", async () => {
+    const members = [
+      makeSubCommand("integration", "Install completion"),
+      makeSubCommand("complete", "Generate completions"),
+    ];
+    const group = makeGroupCommand(
+      "completions",
+      "Completion management",
+      members,
+    );
+    const service = createService([group]);
+
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli comp",
+      10,
+    );
+    const values = result.map((r) => r.value);
+    expect(values).toContain("completions");
+    expect(values).toContain("completions:integration");
+    expect(values).toContain("completions:complete");
+  });
+
+  test("completes member sub-commands after group:", async () => {
+    const members = [
+      makeSubCommand("integration", "Install completion"),
+      makeSubCommand("complete", "Generate completions"),
+    ];
+    const group = makeGroupCommand(
+      "completions",
+      "Completion management",
+      members,
+    );
+    const service = createService([group]);
+
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli completions:i",
+      19,
+    );
+    const values = result.map((r) => r.value);
+    expect(values).toContain("completions:integration");
+    expect(values).not.toContain("completions:complete");
+  });
+
+  test("completes sub-command options", async () => {
+    const cmd = makeSubCommand("deploy", "Deploy app", [
+      {
+        name: "target",
+        type: ArgumentValueTypeName.STRING,
+        description: "Deploy target",
+        isOptional: true,
+      },
+      {
+        name: "force",
+        type: ArgumentValueTypeName.BOOLEAN,
+        description: "Force deploy",
+        isOptional: true,
+        shortAlias: "f",
+      },
+    ]);
+    const service = createService([cmd]);
+
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli deploy --t",
+      16,
+    );
+    const values = result.map((r) => r.value);
+    expect(values).toContain("--target");
+  });
+
+  test("completes option allowable values", async () => {
+    const cmd = makeSubCommand("deploy", "Deploy app", [
+      {
+        name: "env",
+        type: ArgumentValueTypeName.STRING,
+        description: "Environment",
+        isOptional: true,
+        allowableValues: ["staging", "production", "development"],
+      },
+    ]);
+    const service = createService([cmd]);
+
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli deploy --env st",
+      21,
+    );
+    const values = result.map((r) => r.value);
+    expect(values).toContain("staging");
+    expect(values).not.toContain("production");
+  });
+
+  test("completes global modifier commands with -- prefix", async () => {
+    const modifier = makeGlobalModifierCommand(
+      "verbose",
+      "Enable verbose output",
+    );
+    const cmd = makeSubCommand("run", "Run something");
+    const service = createService([modifier, cmd]);
+
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli --v",
+      9,
+    );
+    const values = result.map((r) => r.value);
+    expect(values).toContain("--verbose");
+  });
+
+  test("completes global commands with -- prefix", async () => {
+    const global = makeGlobalCommand("version", "Show version");
+    const cmd = makeSubCommand("run", "Run something");
+    const service = createService([global, cmd]);
+
+    const result = await service.generateCompletions(
+      ShellType.BASH,
+      "mycli --ver",
+      11,
+    );
+    const values = result.map((r) => r.value);
+    expect(values).toContain("--version");
+  });
+
+  test("formatCompletions delegates to shell handler", () => {
+    const service = new DefaultCompletionService();
+    const result = service.formatCompletions(ShellType.FISH, [
+      { value: "help", description: "Display help" },
+    ]);
+    expect(result).toEqual("help\tDisplay help");
+  });
+
+  test("getBootstrapScript delegates to shell handler", () => {
+    const service = new DefaultCompletionService();
+    const result = service.getBootstrapScript(ShellType.BASH, "mycli");
+    expect(result).toContain("_mycli_completions");
+  });
+
+  test("getDefaultConfigPath delegates to shell handler", () => {
+    const service = new DefaultCompletionService();
+    const result = service.getDefaultConfigPath(ShellType.ZSH);
+    expect(result).toEndWith(path.sep + ".zshrc");
+  });
+
+  test("parseCompletionContext delegates to shell handler", () => {
+    const service = new DefaultCompletionService();
+    const result = service.parseCompletionContext(ShellType.BASH, [
+      "mycli help",
+      "10",
+    ]);
+    expect(result.line).toEqual("mycli help");
+    expect(result.cursorPosition).toEqual(10);
+  });
+});