@pragma-sh/kimi-plugin 0.1.0-alpha.0

package/dist/install.mjs

@@ -0,0 +1,86 @@
+// scripts/install-local.ts
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+var RUNTIME_PATHS = ["assets", "dist", "hooks", "kimi.plugin.json", "package.json"];
+function installLocal(kimiHome = process.env.KIMI_CODE_HOME ?? join(homedir(), ".kimi-code"), packageRoot = PACKAGE_ROOT) {
+  const manifest = JSON.parse(readFileSync(join(packageRoot, "kimi.plugin.json"), "utf8"));
+  if (typeof manifest.name !== "string" || manifest.name.length === 0) {
+    throw new Error('kimi.plugin.json must contain a non-empty "name"');
+  }
+  for (const relativePath of RUNTIME_PATHS) {
+    if (!existsSync(join(packageRoot, relativePath))) {
+      throw new Error(`Missing runtime path: ${relativePath}`);
+    }
+  }
+  const id = manifest.name.toLowerCase();
+  const pluginsDir = join(kimiHome, "plugins");
+  const managedDir = join(pluginsDir, "managed");
+  const target = join(managedDir, id);
+  mkdirSync(managedDir, { recursive: true });
+  const staging = mkdtempSync(join(managedDir, `${id}-`));
+  try {
+    for (const relativePath of RUNTIME_PATHS) {
+      cpSync(join(packageRoot, relativePath), join(staging, relativePath), { recursive: true });
+    }
+    rmSync(target, { recursive: true, force: true });
+    renameSync(staging, target);
+  } catch (error) {
+    rmSync(staging, { recursive: true, force: true });
+    throw error;
+  }
+  const installedPath = join(pluginsDir, "installed.json");
+  const installed = readInstalled(installedPath);
+  const existingIndex = installed.plugins.findIndex((plugin) => plugin.id === id);
+  const existing = existingIndex < 0 ? undefined : installed.plugins[existingIndex];
+  const now = new Date().toISOString();
+  const record = {
+    ...existing,
+    id,
+    root: target,
+    source: "local-path",
+    enabled: existing?.enabled ?? true,
+    installedAt: typeof existing?.installedAt === "string" && existing.installedAt.length > 0 ? existing.installedAt : now,
+    updatedAt: now,
+    originalSource: packageRoot
+  };
+  if (existingIndex < 0)
+    installed.plugins.push(record);
+  else
+    installed.plugins[existingIndex] = record;
+  const tempPath = `${installedPath}.${process.pid}.tmp`;
+  writeFileSync(tempPath, `${JSON.stringify(installed, null, 2)}
+`);
+  renameSync(tempPath, installedPath);
+  return target;
+}
+function readInstalled(path) {
+  if (!existsSync(path))
+    return { version: 1, plugins: [] };
+  const value = JSON.parse(readFileSync(path, "utf8"));
+  if (value.version !== 1 || !Array.isArray(value.plugins)) {
+    throw new Error(`${path} is not a valid Kimi installed.json file`);
+  }
+  return { version: 1, plugins: value.plugins };
+}
+var entryPath = process.argv[1];
+if (entryPath !== undefined && resolve(entryPath) === fileURLToPath(import.meta.url)) {
+  const target = installLocal();
+  process.stdout.write(`Installed Pragma Kimi plugin to ${target}.
+`);
+  process.stdout.write("Run `/plugins reload` or start a new Kimi session to load it.\n");
+}
+export {
+  installLocal
+};

package/dist/pragma-plugin.mjs

@@ -0,0 +1,437 @@
+// ../plugin/dist/shared/chunk-k5kqv14t.js
+var PLUGIN_API_VERSION = "0.0.0";
+
+// ../plugin/dist/shared/chunk-0rpz2gg0.js
+function defineAgent(input) {
+  return input;
+}
+function definePlugin(input) {
+  return { ...input, __apiVersion: PLUGIN_API_VERSION };
+}
+
+// ../watcher-kit/src/index.ts
+var DEFAULT_APPROVE_KEYS = "\r";
+var RIGHT_ARROW = "\x1B[C";
+var DOWN_ARROW = "\x1B[B";
+var DEFAULT_DENY_KEYS = `${RIGHT_ARROW}${RIGHT_ARROW}\r`;
+var DEFAULT_SUBMIT_KEYS = "\r";
+var BRACKETED_PASTE_START = "\x1B[200~";
+var BRACKETED_PASTE_END = "\x1B[201~";
+var QUESTION_REJECT_KEYS = "\x1B";
+var QUESTION_DIGIT_MAX = 9;
+var QUESTION_PROMPT_MOUNT_DELAY_MS = 150;
+var QUESTION_OTHER_INPUT_DELAY_MS = 150;
+var QUESTION_NEXT_PROMPT_DELAY_MS = 500;
+var ANSWER_SEPARATOR = "\x1F";
+var RESUBSCRIBE_DELAY_MS = 500;
+var DEFAULT_INTERJECT_SUBMIT_DELAY_MS = 200;
+function createTuiWatcher(options) {
+  const {
+    agent,
+    handleDecisions,
+    handleQuestionAnswers = handleDecisions,
+    interjectSubmitDelayMs = DEFAULT_INTERJECT_SUBMIT_DELAY_MS,
+    interjectMode = "bracketed",
+    interjectSubmitKeys,
+    questionSelectMode = "digit",
+    questionOtherMode = "navigate-enter",
+    questionDismissKeys = QUESTION_REJECT_KEYS,
+    questionFinalizeKeys = ""
+  } = options;
+  return {
+    agent,
+    async watch(ctx) {
+      const watcherContext = ctx;
+      const runtime = {
+        keys: resolveKeys(watcherContext.config, interjectSubmitKeys),
+        handleDecisions,
+        handleQuestionAnswers,
+        interjectSubmitDelayMs,
+        interjectMode,
+        questionSelectMode,
+        questionOtherMode,
+        questionDismissKeys,
+        questionFinalizeKeys,
+        seenRequestIds: new Set,
+        questionsByRequestId: new Map,
+        outstandingCommandRequestId: null
+      };
+      let failures = 0;
+      while (!ctx.signal.aborted) {
+        try {
+          await consumeControlEvents(watcherContext, runtime);
+          failures = 0;
+        } catch (error) {
+          failures += 1;
+          reportStreamFailure(agent, failures, error);
+        }
+        if (ctx.signal.aborted) {
+          return;
+        }
+        await delay(RESUBSCRIBE_DELAY_MS, ctx.signal);
+      }
+    }
+  };
+}
+function reportStreamFailure(agent, consecutive, error) {
+  if (consecutive !== 1 && consecutive % STREAM_FAILURE_LOG_EVERY !== 0) {
+    return;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(JSON.stringify({ type: "watcher.streamError", agent, consecutive, error: message }));
+}
+var STREAM_FAILURE_LOG_EVERY = 240;
+function resolveKeys(config, interjectSubmitKeys) {
+  const c = config ?? {};
+  return {
+    approveKeys: c.approveKeys ?? DEFAULT_APPROVE_KEYS,
+    denyKeys: c.denyKeys ?? DEFAULT_DENY_KEYS,
+    submitKeys: c.submitKeys ?? interjectSubmitKeys ?? DEFAULT_SUBMIT_KEYS
+  };
+}
+async function consumeControlEvents(ctx, runtime) {
+  const connection = await ctx.sdk.agents.connect({
+    agent: ctx.agentId,
+    tabId: ctx.session.tabId,
+    worktreeId: ctx.session.worktreeId,
+    signal: ctx.signal
+  });
+  for await (const event of connection) {
+    if (ctx.signal.aborted) {
+      return;
+    }
+    await handleControlEvent(ctx, runtime, event);
+  }
+}
+async function handleControlEvent(ctx, runtime, event) {
+  if (event.type === "agent") {
+    if (runtime.handleQuestionAnswers)
+      rememberQuestion(runtime.questionsByRequestId, event);
+    if (runtime.handleDecisions)
+      rememberCommandAttention(runtime, event);
+    return;
+  }
+  if (runtime.handleDecisions && await handleDecision(ctx, runtime, event)) {
+    return;
+  }
+  if (runtime.handleQuestionAnswers && await handleAnswer(ctx, runtime, event)) {
+    return;
+  }
+  if (event.type === "agentInput") {
+    await handleInterjection(ctx, runtime.keys.submitKeys, runtime.interjectSubmitDelayMs, runtime.interjectMode, event.input.text);
+  }
+}
+async function handleDecision(ctx, runtime, event) {
+  if (event.type !== "agentDecision")
+    return false;
+  if (runtime.seenRequestIds.has(event.decision.requestId))
+    return true;
+  runtime.seenRequestIds.add(event.decision.requestId);
+  if (runtime.outstandingCommandRequestId !== null && runtime.outstandingCommandRequestId !== event.decision.requestId) {
+    return true;
+  }
+  runtime.outstandingCommandRequestId = null;
+  await writeKeys(ctx, event.decision.approved ? runtime.keys.approveKeys : runtime.keys.denyKeys);
+  return true;
+}
+async function handleAnswer(ctx, runtime, event) {
+  if (event.type !== "agentAnswer")
+    return false;
+  const { answer } = event;
+  const cached = runtime.questionsByRequestId.get(answer.requestId);
+  if (!cached)
+    return true;
+  if (runtime.seenRequestIds.has(answer.requestId))
+    return true;
+  runtime.seenRequestIds.add(answer.requestId);
+  runtime.questionsByRequestId.delete(answer.requestId);
+  await delay(QUESTION_PROMPT_MOUNT_DELAY_MS, ctx.signal);
+  if (ctx.signal.aborted)
+    return true;
+  const reply = answer.answer?.trim() ?? null;
+  if (cached.questions.length > 1) {
+    if (!answer.dismissed && reply) {
+      await writeMultipleQuestionAnswers(ctx, runtime, cached.questions, reply);
+    } else if (answer.dismissed || !reply) {
+      await writeKeys(ctx, runtime.questionDismissKeys);
+    }
+    return true;
+  }
+  const single = cached.questions[0] ?? { question: "", options: [] };
+  await writeQuestionAnswer(ctx, runtime, single, reply, answer.dismissed);
+  if (!answer.dismissed && reply)
+    await finalizeQuestionAnswers(ctx, runtime);
+  return true;
+}
+async function writeQuestionAnswer(ctx, runtime, question, reply, dismissed) {
+  if (dismissed || !reply) {
+    await writeKeys(ctx, runtime.questionDismissKeys);
+    return;
+  }
+  if (!dismissed && reply && !question.options.includes(reply)) {
+    await writeFreeTextAnswer(ctx, question.options.length, reply, runtime.questionSelectMode, runtime.questionOtherMode);
+    return;
+  }
+  const strokes = questionAnswerKeys({
+    dismissed,
+    reply,
+    options: question.options,
+    selectMode: runtime.questionSelectMode
+  });
+  if (strokes)
+    await writeKeys(ctx, strokes);
+}
+async function writeFreeTextAnswer(ctx, optionCount, reply, selectMode, otherMode) {
+  await writeKeys(ctx, openOtherEditorKeys(optionCount, selectMode, otherMode));
+  await delay(QUESTION_OTHER_INPUT_DELAY_MS, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, `${reply}\r`);
+}
+async function writeMultipleQuestionAnswers(ctx, runtime, questions, combined) {
+  const replies = combined.split(ANSWER_SEPARATOR).map((reply) => reply.trim());
+  for (const [index, question] of questions.entries()) {
+    const reply = replies[index];
+    if (!reply || ctx.signal.aborted)
+      return;
+    await writeQuestionAnswer(ctx, runtime, question, reply, false);
+    if (index < questions.length - 1) {
+      await delay(QUESTION_NEXT_PROMPT_DELAY_MS, ctx.signal);
+    }
+  }
+  await finalizeQuestionAnswers(ctx, runtime);
+}
+async function finalizeQuestionAnswers(ctx, runtime) {
+  if (!runtime.questionFinalizeKeys || ctx.signal.aborted)
+    return;
+  await delay(QUESTION_NEXT_PROMPT_DELAY_MS, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, runtime.questionFinalizeKeys);
+}
+async function handleInterjection(ctx, submitKeys, submitDelayMs, mode, text) {
+  const input = mode === "plain" ? text : `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+  await writeKeys(ctx, input);
+  if (!submitKeys) {
+    return;
+  }
+  await delay(submitDelayMs, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, submitKeys);
+}
+function rememberCommandAttention(runtime, event) {
+  if (event.status === "attention" && event.attentionKind === "command" && typeof event.requestId === "string" && event.requestId.length > 0) {
+    runtime.outstandingCommandRequestId = event.requestId;
+    return;
+  }
+  if (event.status !== "attention") {
+    runtime.outstandingCommandRequestId = null;
+  }
+}
+function rememberQuestion(cache, event) {
+  if (event.status === "attention" && event.attentionKind === "question" && typeof event.requestId === "string" && event.requestId.length > 0) {
+    const entries = (event.questions ?? []).flatMap(questionEntry);
+    if (entries.length > 0) {
+      cache.set(event.requestId, { questions: entries });
+      return;
+    }
+    const options = (event.options ?? []).map((option) => option.label).filter((option) => option.trim() !== "");
+    cache.set(event.requestId, {
+      questions: [{ question: event.question ?? "", options }]
+    });
+  }
+}
+function questionEntry(value) {
+  if (typeof value !== "object" || value === null || !("question" in value)) {
+    return [];
+  }
+  const record = value;
+  if (typeof record.question !== "string" || !record.question.trim()) {
+    return [];
+  }
+  const options = Array.isArray(record.options) ? record.options.filter((option) => Boolean(option) && typeof option === "object").map((option) => option.label).filter((label) => typeof label === "string" && label.trim() !== "") : [];
+  return [{ question: record.question, options }];
+}
+function questionAnswerKeys(input) {
+  if (input.dismissed || input.reply === null) {
+    return QUESTION_REJECT_KEYS;
+  }
+  const reply = input.reply.trim();
+  if (!reply) {
+    return QUESTION_REJECT_KEYS;
+  }
+  const options = input.options;
+  const selectMode = input.selectMode ?? "digit";
+  const matchIndex = options.findIndex((option) => option === reply);
+  if (matchIndex >= 0) {
+    return selectOptionKeys(matchIndex, options.length, selectMode);
+  }
+  return `${openOtherEditorKeys(options.length, selectMode, "navigate-enter")}${reply}\r`;
+}
+function openOtherEditorKeys(optionCount, selectMode, otherMode) {
+  if (otherMode === "shortcut-z")
+    return "z";
+  const navigate = DOWN_ARROW.repeat(optionCount);
+  return selectMode === "arrow-space" || otherMode === "navigate" ? navigate : `${navigate}\r`;
+}
+function selectOptionKeys(index, optionCount, selectMode) {
+  if (selectMode === "arrow-space") {
+    return `${DOWN_ARROW.repeat(index)} \r`;
+  }
+  const total = optionCount + 1;
+  if (index < QUESTION_DIGIT_MAX && index < total) {
+    return String(index + 1);
+  }
+  return `${DOWN_ARROW.repeat(index)}\r`;
+}
+async function writeKeys(ctx, data) {
+  try {
+    await ctx.sendKeys(data);
+  } catch {}
+}
+function delay(ms, signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const finish = () => resolve();
+    const timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      finish();
+    }, { once: true });
+  });
+}
+
+// src/models.ts
+var KIMI_BIN_DIR = "$HOME/.kimi-code/bin";
+var KIMI_MODELS_COMMAND = `kimi provider list --json || "${KIMI_BIN_DIR}/kimi" provider list --json`;
+var KIMI_DEFAULT_MODEL_COMMAND = `kimi provider list || "${KIMI_BIN_DIR}/kimi" provider list`;
+async function loadKimiModels(ctx) {
+  try {
+    const results = await ctx.sdk.exec.run({
+      cwd: ctx.project?.path ?? "/tmp",
+      commands: [KIMI_MODELS_COMMAND, KIMI_DEFAULT_MODEL_COMMAND]
+    });
+    return kimiModelsFromConfig(parseKimiProviderModels(results[0]?.stdout ?? ""), parseKimiDefaultModel(results[1]?.stdout ?? ""));
+  } catch {
+    return [];
+  }
+}
+function kimiModelsFromConfig(config, defaultModel) {
+  const entries = Object.entries(config).map(([id, model]) => ({
+    id,
+    name: model.displayName ?? model.model
+  }));
+  const defaultIndex = entries.findIndex((entry) => entry.id === defaultModel);
+  if (defaultIndex > 0) {
+    const [entry] = entries.splice(defaultIndex, 1);
+    if (entry !== undefined)
+      entries.unshift(entry);
+  }
+  return entries;
+}
+function parseKimiProviderModels(output) {
+  let value;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    return {};
+  }
+  const models = recordValue(recordValue(value)?.models);
+  if (models === undefined)
+    return {};
+  const parsed = {};
+  for (const [alias, candidate] of Object.entries(models)) {
+    const model = recordValue(candidate);
+    if (model === undefined || typeof model.model !== "string" || model.model.length === 0) {
+      continue;
+    }
+    if (model.disabled === true)
+      continue;
+    parsed[alias] = {
+      provider: typeof model.provider === "string" ? model.provider : "",
+      model: model.model,
+      ...typeof model.displayName === "string" ? { displayName: model.displayName } : {}
+    };
+  }
+  return parsed;
+}
+function parseKimiDefaultModel(output) {
+  const match = /^Default model:\s*(.+)$/m.exec(output);
+  return match?.[1]?.trim() || undefined;
+}
+function recordValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+
+// src/pragma-plugin.ts
+var INTERJECT_SUBMIT_DELAY_MS = 200;
+var PREFILL_DELAY_MS = 2500;
+var baseWatcher = createTuiWatcher({
+  agent: "kimi",
+  handleDecisions: false,
+  handleQuestionAnswers: true,
+  questionFinalizeKeys: "1",
+  interjectSubmitDelayMs: INTERJECT_SUBMIT_DELAY_MS
+});
+var kimiAgentPlugin = definePlugin({
+  name: "Kimi Code",
+  description: "Launch Kimi Code from Pragma.",
+  watchers: [
+    {
+      agent: "kimi",
+      async watch(ctx) {
+        try {
+          await baseWatcher.watch(ctx);
+        } finally {
+          try {
+            await ctx.sdk.agents.report({
+              agent: ctx.agentId,
+              tabId: ctx.session.tabId,
+              worktreeId: ctx.session.worktreeId,
+              status: "cleared",
+              attentionKind: null
+            });
+          } catch {}
+        }
+      }
+    }
+  ],
+  agents: [
+    defineAgent({
+      id: "kimi",
+      name: "Kimi Code",
+      icon: () => null,
+      iconPath: "assets/kimi.png",
+      launch: { command: ["kimi", "-y"] },
+      prefillDelayMs: PREFILL_DELAY_MS,
+      prefillMode: "plain",
+      prefillSubmit: "\r",
+      models: loadKimiModels,
+      permissionModes: [
+        { id: "yolo", name: "Auto-approve tools" },
+        { id: "default", name: "Ask for approval" },
+        { id: "auto", name: "Fully autonomous" },
+        { id: "plan", name: "Plan mode" }
+      ],
+      excludeFeatures: ["commandApproval"],
+      args: {
+        model: (modelId) => ["-m", modelId],
+        reasoning: () => [],
+        permissionMode: (permissionModeId) => {
+          if (permissionModeId === "yolo") {
+            return [];
+          }
+          if (permissionModeId === "auto") {
+            return ["--auto"];
+          }
+          return permissionModeId === "plan" ? ["--plan"] : [];
+        }
+      }
+    })
+  ]
+});
+var pragma_plugin_default = kimiAgentPlugin;
+export {
+  kimiAgentPlugin,
+  pragma_plugin_default as default
+};