terminal-pilot 0.0.5 → 0.0.7

package/dist/commands/uninstall.js

@@ -0,0 +1,529 @@
+// ../cmdkit/src/index.ts
+import { fileURLToPath } from "node:url";
+
+// ../cmdkit-schema/src/index.ts
+function assertValidEnumValues(values) {
+  if (values.length === 0) {
+    throw new Error("Enum schema requires at least one value");
+  }
+  const uniqueValues = new Set(values);
+  if (uniqueValues.size !== values.length) {
+    throw new Error("Enum schema values must be unique");
+  }
+}
+var S = {
+  String(options = {}) {
+    return {
+      kind: "string",
+      ...options
+    };
+  },
+  Number(options = {}) {
+    return {
+      kind: "number",
+      ...options
+    };
+  },
+  Boolean(options = {}) {
+    return {
+      kind: "boolean",
+      ...options
+    };
+  },
+  Enum(values, options = {}) {
+    assertValidEnumValues(values);
+    return {
+      kind: "enum",
+      values,
+      ...options
+    };
+  },
+  Array(item, options = {}) {
+    return {
+      kind: "array",
+      item,
+      ...options
+    };
+  },
+  Object(shape) {
+    return {
+      kind: "object",
+      shape
+    };
+  },
+  Optional(inner) {
+    return {
+      kind: "optional",
+      inner
+    };
+  }
+};
+
+// ../cmdkit/src/index.ts
+var commandConfigSymbol = /* @__PURE__ */ Symbol("cmdkit.command.config");
+var commandSourcePathSymbol = /* @__PURE__ */ Symbol("cmdkit.command.sourcePath");
+var UserError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserError";
+  }
+};
+function cloneScope(scope) {
+  return scope === void 0 ? void 0 : [...scope];
+}
+function cloneSecretDefinition(secret) {
+  return {
+    env: secret.env,
+    description: secret.description,
+    optional: secret.optional
+  };
+}
+function cloneSecrets(secrets) {
+  if (secrets === void 0) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(secrets).map(([key, secret]) => [key, cloneSecretDefinition(secret)])
+  );
+}
+function cloneRequires(requires) {
+  if (requires === void 0) {
+    return void 0;
+  }
+  return {
+    auth: requires.auth,
+    apiVersion: requires.apiVersion,
+    check: requires.check
+  };
+}
+function parseStackPath(candidate) {
+  if (candidate.startsWith("file://")) {
+    try {
+      return fileURLToPath(candidate);
+    } catch {
+      return void 0;
+    }
+  }
+  if (candidate.startsWith("/")) {
+    return candidate;
+  }
+  return void 0;
+}
+function extractStackPath(line) {
+  const trimmed = line.trim();
+  const fileIndex = trimmed.indexOf("file://");
+  if (fileIndex >= 0) {
+    const location2 = trimmed.slice(fileIndex);
+    const separatorIndex2 = location2.lastIndexOf(":");
+    const previousSeparatorIndex2 = separatorIndex2 >= 0 ? location2.lastIndexOf(":", separatorIndex2 - 1) : -1;
+    const candidate2 = separatorIndex2 >= 0 && previousSeparatorIndex2 >= 0 ? location2.slice(0, previousSeparatorIndex2) : location2;
+    return parseStackPath(candidate2);
+  }
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex < 0) {
+    return void 0;
+  }
+  const location = trimmed.slice(slashIndex);
+  const separatorIndex = location.lastIndexOf(":");
+  const previousSeparatorIndex = separatorIndex >= 0 ? location.lastIndexOf(":", separatorIndex - 1) : -1;
+  const candidate = separatorIndex >= 0 && previousSeparatorIndex >= 0 ? location.slice(0, previousSeparatorIndex) : location;
+  return parseStackPath(candidate);
+}
+function inferCommandSourcePath() {
+  const stack = new Error().stack;
+  if (typeof stack !== "string") {
+    return void 0;
+  }
+  for (const line of stack.split("\n").slice(1)) {
+    const candidate = extractStackPath(line);
+    if (candidate === void 0) {
+      continue;
+    }
+    if (candidate.includes("/packages/cmdkit/src/index.ts") || candidate.includes("/packages/cmdkit/dist/index.js")) {
+      continue;
+    }
+    return candidate;
+  }
+  return void 0;
+}
+function composeChecks(parentCheck, childCheck) {
+  if (parentCheck === void 0) {
+    return childCheck;
+  }
+  if (childCheck === void 0) {
+    return parentCheck;
+  }
+  return async (ctx) => {
+    const parentResult = await parentCheck(ctx);
+    if (!parentResult.ok) {
+      return parentResult;
+    }
+    return childCheck(ctx);
+  };
+}
+function mergeRequires(parent, child) {
+  if (parent === void 0 && child === void 0) {
+    return void 0;
+  }
+  const merged = {
+    auth: child?.auth ?? parent?.auth,
+    apiVersion: child?.apiVersion ?? parent?.apiVersion,
+    check: composeChecks(parent?.check, child?.check)
+  };
+  if (merged.auth === void 0 && merged.apiVersion === void 0 && merged.check === void 0) {
+    return void 0;
+  }
+  return merged;
+}
+function mergeSecrets(parent, child) {
+  return cloneSecrets({
+    ...parent,
+    ...child
+  });
+}
+function resolveCommandScope(ownScope, inheritedScope) {
+  return cloneScope(ownScope ?? inheritedScope) ?? ["cli", "sdk"];
+}
+function createBaseCommand(config) {
+  const command = {
+    kind: "command",
+    name: config.name,
+    description: config.description,
+    aliases: [...config.aliases ?? []],
+    positional: [...config.positional ?? []],
+    params: config.params,
+    secrets: cloneSecrets(config.secrets),
+    scope: resolveCommandScope(config.scope, void 0),
+    confirm: config.confirm ?? false,
+    requires: cloneRequires(config.requires),
+    handler: config.handler,
+    render: config.render
+  };
+  Object.defineProperty(command, commandConfigSymbol, {
+    value: {
+      scope: cloneScope(config.scope),
+      secrets: cloneSecrets(config.secrets),
+      requires: cloneRequires(config.requires),
+      sourcePath: inferCommandSourcePath()
+    }
+  });
+  return command;
+}
+function getInternalCommandConfig(command) {
+  return command[commandConfigSymbol];
+}
+function materializeCommand(command, inherited) {
+  const internal = getInternalCommandConfig(command);
+  const materialized = {
+    kind: "command",
+    name: command.name,
+    description: command.description,
+    aliases: [...command.aliases],
+    positional: [...command.positional],
+    params: command.params,
+    secrets: mergeSecrets(inherited.secrets, internal.secrets),
+    scope: resolveCommandScope(internal.scope, inherited.scope),
+    confirm: command.confirm,
+    requires: mergeRequires(inherited.requires, internal.requires),
+    handler: command.handler,
+    render: command.render
+  };
+  Object.defineProperty(materialized, commandConfigSymbol, {
+    value: {
+      scope: cloneScope(internal.scope),
+      secrets: cloneSecrets(internal.secrets),
+      requires: cloneRequires(internal.requires),
+      sourcePath: internal.sourcePath
+    }
+  });
+  Object.defineProperty(materialized, commandSourcePathSymbol, {
+    value: internal.sourcePath
+  });
+  return materialized;
+}
+function defineCommand(config) {
+  return materializeCommand(createBaseCommand(config), {
+    scope: void 0,
+    secrets: {},
+    requires: void 0
+  });
+}
+
+// src/commands/installer.ts
+import os2 from "node:os";
+import path3 from "node:path";
+import * as nodeFs from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
+
+// ../agent-skill-config/src/configs.ts
+import os from "node:os";
+import path from "node:path";
+
+// ../agent-defs/src/agents/claude-code.ts
+var claudeCodeAgent = {
+  id: "claude-code",
+  name: "claude-code",
+  label: "Claude Code",
+  summary: "Configure Claude Code to route through Poe.",
+  aliases: ["claude"],
+  binaryName: "claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#C15F3C",
+      light: "#C15F3C"
+    }
+  }
+};
+
+// ../agent-defs/src/agents/claude-desktop.ts
+var claudeDesktopAgent = {
+  id: "claude-desktop",
+  name: "claude-desktop",
+  label: "Claude Desktop",
+  summary: "Anthropic's official desktop application for Claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#D97757",
+      light: "#D97757"
+    }
+  }
+};
+
+// ../agent-defs/src/agents/codex.ts
+var codexAgent = {
+  id: "codex",
+  name: "codex",
+  label: "Codex",
+  summary: "Configure Codex to use Poe as the model provider.",
+  binaryName: "codex",
+  configPath: "~/.codex/config.toml",
+  branding: {
+    colors: {
+      dark: "#D5D9DF",
+      light: "#7A7F86"
+    }
+  }
+};
+
+// ../agent-defs/src/agents/opencode.ts
+var openCodeAgent = {
+  id: "opencode",
+  name: "opencode",
+  label: "OpenCode CLI",
+  summary: "Configure OpenCode CLI to use the Poe API.",
+  binaryName: "opencode",
+  configPath: "~/.config/opencode/config.json",
+  branding: {
+    colors: {
+      dark: "#4A4F55",
+      light: "#2F3338"
+    }
+  }
+};
+
+// ../agent-defs/src/agents/kimi.ts
+var kimiAgent = {
+  id: "kimi",
+  name: "kimi",
+  label: "Kimi",
+  summary: "Configure Kimi CLI to use Poe API",
+  aliases: ["kimi-cli"],
+  binaryName: "kimi",
+  configPath: "~/.kimi/config.toml",
+  branding: {
+    colors: {
+      dark: "#7B68EE",
+      light: "#6A5ACD"
+    }
+  }
+};
+
+// ../agent-defs/src/registry.ts
+var allAgents = [
+  claudeCodeAgent,
+  claudeDesktopAgent,
+  codexAgent,
+  openCodeAgent,
+  kimiAgent
+];
+var lookup = /* @__PURE__ */ new Map();
+for (const agent of allAgents) {
+  const values = [agent.id, agent.name, ...agent.aliases ?? []];
+  for (const value of values) {
+    const normalized = value.toLowerCase();
+    if (!lookup.has(normalized)) {
+      lookup.set(normalized, agent.id);
+    }
+  }
+}
+function resolveAgentId(input) {
+  if (!input) {
+    return void 0;
+  }
+  return lookup.get(input.toLowerCase());
+}
+
+// ../agent-skill-config/src/configs.ts
+var agentSkillConfigs = {
+  "claude-code": {
+    globalSkillDir: "~/.claude/skills",
+    localSkillDir: ".claude/skills"
+  },
+  codex: {
+    globalSkillDir: "~/.codex/skills",
+    localSkillDir: ".codex/skills"
+  },
+  opencode: {
+    globalSkillDir: "~/.config/opencode/skills",
+    localSkillDir: ".opencode/skills"
+  }
+};
+var supportedAgents = Object.keys(agentSkillConfigs);
+function resolveAgentSupport(input, registry = agentSkillConfigs) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return { status: "unknown", input };
+  }
+  const config = registry[resolvedId];
+  if (!config) {
+    return { status: "unsupported", input, id: resolvedId };
+  }
+  return { status: "supported", input, id: resolvedId, config };
+}
+function getAgentConfig(agentId) {
+  const support = resolveAgentSupport(agentId);
+  return support.status === "supported" ? support.config : void 0;
+}
+
+// ../config-mutations/src/execution/apply-mutation.ts
+import Mustache from "mustache";
+
+// ../config-mutations/src/formats/json.ts
+import * as jsonc from "jsonc-parser";
+
+// ../config-mutations/src/formats/toml.ts
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+
+// ../config-mutations/src/execution/path-utils.ts
+import path2 from "node:path";
+
+// ../config-mutations/src/template/render.ts
+import Mustache2 from "mustache";
+var originalEscape = Mustache2.escape;
+
+// ../agent-skill-config/src/templates.ts
+import { readFile } from "node:fs/promises";
+
+// src/commands/installer.ts
+var DEFAULT_INSTALL_AGENT = "claude-code";
+var TERMINAL_PILOT_SKILL_NAME = "terminal-pilot";
+var installableAgents = supportedAgents;
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function resolveInstallerServices(installer) {
+  return {
+    fs: installer?.fs ?? nodeFs,
+    cwd: installer?.cwd ?? process.cwd(),
+    homeDir: installer?.homeDir ?? os2.homedir(),
+    platform: installer?.platform ?? process.platform
+  };
+}
+function throwUnsupportedAgent(agent) {
+  throw new UserError(`Unsupported agent: ${agent}`);
+}
+function resolveInstallableAgent(agent) {
+  const skillSupport = resolveAgentSupport(agent);
+  if (skillSupport.status !== "supported" || !skillSupport.id) {
+    throwUnsupportedAgent(agent);
+  }
+  return skillSupport.id;
+}
+function resolveHomeRelativePath(targetPath, homeDir) {
+  if (targetPath === "~") {
+    return homeDir;
+  }
+  if (targetPath.startsWith("~/")) {
+    return path3.join(homeDir, targetPath.slice(2));
+  }
+  return targetPath;
+}
+function getSkillFolderWithHome(agent, scope, cwd, homeDir) {
+  const config = getAgentConfig(agent);
+  if (!config) {
+    throwUnsupportedAgent(agent);
+  }
+  return {
+    displayPath: path3.join(
+      scope === "global" ? config.globalSkillDir : config.localSkillDir,
+      TERMINAL_PILOT_SKILL_NAME
+    ),
+    fullPath: path3.join(
+      scope === "global" ? resolveHomeRelativePath(config.globalSkillDir, homeDir) : path3.resolve(cwd, config.localSkillDir),
+      TERMINAL_PILOT_SKILL_NAME
+    )
+  };
+}
+async function removeSkillFolder(fs, folderPath) {
+  try {
+    await fs.stat(folderPath);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return false;
+    }
+    throw error;
+  }
+  if (typeof fs.rm !== "function") {
+    throw new UserError("The configured filesystem does not support removing directories.");
+  }
+  await fs.rm(folderPath, { recursive: true, force: true });
+  return true;
+}
+
+// src/commands/uninstall.ts
+var params = S.Object({
+  agent: S.Enum(installableAgents, {
+    description: "Agent to uninstall terminal-pilot from",
+    default: DEFAULT_INSTALL_AGENT
+  })
+});
+var uninstall = defineCommand({
+  name: "uninstall",
+  description: "Remove the terminal-pilot CLI skill.",
+  scope: ["cli"],
+  positional: ["agent"],
+  params,
+  handler: async ({ params: params2, terminalPilotInstaller }) => {
+    const services = resolveInstallerServices(terminalPilotInstaller);
+    const agent = resolveInstallableAgent(params2.agent);
+    const localSkill = getSkillFolderWithHome(
+      agent,
+      "local",
+      services.cwd,
+      services.homeDir
+    );
+    const globalSkill = getSkillFolderWithHome(
+      agent,
+      "global",
+      services.cwd,
+      services.homeDir
+    );
+    const removedSkillPaths = [];
+    if (await removeSkillFolder(services.fs, localSkill.fullPath)) {
+      removedSkillPaths.push(localSkill.displayPath);
+    }
+    if (await removeSkillFolder(services.fs, globalSkill.fullPath)) {
+      removedSkillPaths.push(globalSkill.displayPath);
+    }
+    return {
+      agent,
+      removedSkillPaths
+    };
+  }
+});
+export {
+  uninstall
+};
+//# sourceMappingURL=uninstall.js.map