dsh-loop-engine 1.0.0-rc5 → 1.0.0-rc7

package/lib/types/engine-kimi/process.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Kimi CLI process projection. The driver locates the `kimi` executable, builds
+ * the `-p --output-format stream-json` argv for one step, and projects the dsh
+ * subprocess seam handle onto a minimal transport the agent can read to
+ * completion. Kimi has no host permission callback and no `--tools` pruning
+ * flag in `-p` mode, so the whole child is spawned through the seam — the only
+ * available privilege boundary (the seam's OS sandbox, default read-only) — and
+ * every step is a fresh one-shot child because `-p` is inherently stateless.
+ *
+ * @module dsh-loop-engine/engine-kimi/process
+ */
+import type { Readable, Writable } from 'node:stream';
+import type { SubprocessHandle, SubprocessSpawnSpec } from '@deepseek-ai/dsh-subprocess';
+/** The exact argv/cwd/env the driver requests for one `kimi -p` child. */
+export interface KimiSpawnSpec {
+    /** The program plus its flags; `argv[0]` is the Kimi CLI executable. */
+    readonly argv: readonly string[];
+    readonly cwd: string;
+    readonly env: Record<string, string>;
+    /** Cancellation: the seam escalates process-tree termination when it fires. */
+    readonly signal?: AbortSignal;
+}
+/** A spawned Kimi process as the agent's transport needs it. */
+export interface KimiProcess {
+    /** Child stdin (JSON-RPC request frames). */
+    readonly stdin: Writable;
+    /** Child stdout (the `session/update` notification frames). */
+    readonly stdout: Readable;
+    /** Child stderr (diagnostics; drained and dropped). */
+    readonly stderr: Readable;
+    /** Resolves when the child closes. */
+    readonly done: Promise<unknown>;
+    /** Request process-tree termination. */
+    terminate(): void;
+}
+/** Spawns one Kimi child over the given spec (the driver's spawn capability). */
+export type KimiSpawnCapability = (spec: KimiSpawnSpec) => KimiProcess;
+/** Resolve the Kimi home directory from `KIMI_CODE_HOME` or the current user's home. */
+export declare function kimiHomeDir(): string;
+/**
+ * Resolve the Kimi CLI executable. An explicit config path wins; otherwise this
+ * probes the standard `<kimi home>/bin/kimi[.exe]` location and falls back to
+ * `'kimi'` (resolved through PATH by the spawner).
+ * @param configBin - an operator-pinned absolute path (or `'kimi'`), if any.
+ * @returns the executable to spawn as `argv[0]`.
+ */
+export declare function kimiBinResolver(configBin?: string): string;
+/**
+ * Build the persistent `kimi acp` argv. The ACP child stays alive across steps
+ * and is spoken to over JSON-RPC on stdio — the prompt is a request body, not an
+ * argv positional — so there is no command-line length ceiling and no model flag
+ * (Kimi owns model selection natively via its own config).
+ * @param bin - the Kimi executable.
+ * @returns the argv, `argv[0]` being the executable.
+ */
+export declare function kimiAcpArgv(bin: string): string[];
+/** Project the driver's spawn request onto the dsh subprocess seam. */
+export declare function kimiSubprocessSpec(spec: KimiSpawnSpec, graceMs: number): SubprocessSpawnSpec;
+/** Project a dsh subprocess handle onto the Kimi process transport. */
+export declare function fromSubprocess(handle: SubprocessHandle): KimiProcess;
+//# sourceMappingURL=process.d.ts.map

package/lib/types/engine-kimi/skills.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Kimi Code skill provider: exposes the Kimi CLI's instruction files and skills
+ * as DSH skills.
+ *
+ * Kimi reads per-directory `AGENTS.md` files from the session cwd up to the git
+ * root, and installs skills from `skills/` directories — the user-level
+ * `$KIMI_CODE_HOME/skills/` (default `~/.kimi-code/skills/`) and the
+ * project-level `.kimi-code/skills/` (walking up to the git root). Each
+ * context-file set is surfaced as one user-invocable `agents-md` skill whose
+ * body is the concatenated file contents; every found `SKILL.md` catalog entry
+ * is surfaced under its own name, so the dsh skill-injection seam (`/name`
+ * gestures) can carry them into the prompt.
+ *
+ * The generic `~/.agents/skills/` and `.agents/skills/` roots are deliberately
+ * not scanned here: dsh's own `skill-filesystem` provider already exposes them
+ * through the same registry in the web profile. Kimi built-in Skills are
+ * shipped inside the CLI and cannot be read from a stable on-disk location, so
+ * the filesystem subset above is authoritative for the web menu. Note the
+ * shared {@link parseSkillFile} mirrors the agents-skill frontmatter
+ * (`name`/`description`/`whenToUse`/`disable-model-invocation`); Kimi's own
+ * `disableModelInvocation`/`type` fields are not translated, so a `type: flow`
+ * skill is surfaced as model-invocable.
+ *
+ * @module dsh-loop-engine/engine-kimi/skills
+ */
+import type { SkillCandidate, SkillDefinition, SkillLookupOptions, SkillProvider, SkillProviderControl } from '../skills.ts';
+/**
+ * Resolve the Kimi config directory, honoring the `KIMI_CODE_HOME` environment
+ * override and falling back to `~/.kimi-code`.
+ * @returns the absolute Kimi config directory.
+ */
+export declare function kimiAgentDir(): string;
+/**
+ * Skill provider that discovers context files and skills from Kimi's standard
+ * locations:
+ *   - project `AGENTS.md` files between the cwd and the git root — surfaced as
+ *     one `agents-md` skill;
+ *   - project `.kimi-code/skills/` and user `~/.kimi-code/skills/` — each
+ *     `SKILL.md` entry surfaced under its own name.
+ */
+export declare class KimiSkillProvider implements SkillProvider {
+    private readonly control;
+    readonly name = "kimi";
+    constructor(control: SkillProviderControl);
+    list(options: SkillLookupOptions): Promise<readonly SkillCandidate[]>;
+    get(candidate: SkillCandidate, _options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
+    /** One merged `agents-md` candidate for a ranked file set. */
+    private agentsCandidate;
+    /** Collect every skill in one skills directory, both kimi layouts. */
+    private collectSkillsDir;
+    /** One parsed skill as a ranked candidate. */
+    private skillCandidate;
+    /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
+    private tryParse;
+}
+export default KimiSkillProvider;
+//# sourceMappingURL=skills.d.ts.map

package/lib/types/engine-kimi/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Public types of the Kimi Code loop driver. Types only — no runtime code.
+ *
+ * Kimi Code (`kimi`) has no host approval callback ("runs with the permissions
+ * of the user"), and its non-interactive `-p` surface already auto-approves tool
+ * calls. It also exposes no `--tools` pruning flag in `-p` mode, so there is no
+ * per-driver permission lever to pin. The driver therefore spawns the whole
+ * `kimi -p` child through the dsh subprocess seam — the only available privilege
+ * boundary — and the sandbox stance follows the session's durable permission
+ * knobs as the subprocess provider resolves them (default read-only).
+ *
+ * @module dsh-loop-engine/engine-kimi/types
+ */
+/** Driver configuration after defaults and load-time validation. */
+export interface ResolvedConfig {
+    /** Model alias the `kimi` child is launched with (`--model`); Kimi native config owns the model when omitted. */
+    readonly model: string | undefined;
+    /** Explicit environment entries layered over the credential-scrubbed parent environment. */
+    readonly env: Record<string, string>;
+    /** Kimi CLI executable; `'kimi'` resolves through PATH when not pinned to an absolute path. */
+    readonly bin: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * Web-switchable agent loop engine, node half.
  *
- * Hosts the non-default agent-loop engines (Claude Code, Codex) and
- * bridges them with the harness's single AgentFactory slot. The engine is
+ * Hosts the non-default agent-loop engines (Claude Code, Codex, Pi, Kimi Code)
+ * and bridges them with the harness's single AgentFactory slot. The engine is
  * selected by the `agent-loop-engine` settings section; the selection is
  * realized by a managed block in the profile's `cordis.patch.yml` that
  * disables the base bundle's `agent-loop` row — exactly one AgentFactory may
@@ -50,6 +50,8 @@ export interface Config extends ClaudeCodeConfig {
     piProvider?: string;
     /** Thinking/reasoning level for the Pi RPC child, appended to its `--model`. */
     piThinking?: string;
+    /** Kimi CLI executable; `'kimi'` resolves through PATH when not pinned to an absolute path. */
+    kimiBin?: string;
 }
 /**
  * Schema of the loop engine composition entry.

package/lib/types/settings.d.ts

@@ -14,7 +14,7 @@ import z from '@deepseek-ai/schemastery';
 import type { SettingsNamespace } from '@deepseek-ai/dsh-settings';
 export { LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL } from './namespace.ts';
 /** The installed engine driving new Agent turns. */
-export declare const LOOP_ENGINE_IDS: readonly ["in-process", "claude-code", "codex", "pi"];
+export declare const LOOP_ENGINE_IDS: readonly ["in-process", "claude-code", "codex", "pi", "kimi"];
 /** Installed agent loop engine id. */
 export type LoopEngineId = (typeof LOOP_ENGINE_IDS)[number];
 /** Stored and composed loop engine selection. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-loop-engine",
-  "description": "Web-switchable agent loop engine selection for the DeepSeek Harness - out-of-tree plugin (Claude Code / Codex drivers) maintained by @kuun993, zero main-repo changes",
-  "version": "1.0.0-rc5",
+  "description": "Web-switchable agent loop engine selection for the DeepSeek Harness - out-of-tree plugin (Claude Code / Codex / Pi / Kimi Code drivers) maintained by @kuun993, zero main-repo changes",
+  "version": "1.0.0-rc7",
   "publishConfig": {
     "access": "public"
   },