deekseek-cli 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# deekseek-cli
+
+Future-ready DeepSeek coding-agent CLI framework preview.
+
+```bash
+npm install -g deekseek-cli
+deepseek -p "smoke"
+deepseek -p "smoke" --output stream-json
+```
+
+This first package contains the deterministic headless smoke path and thin CLI host adapter. Production model credentials and live provider behavior are intentionally outside this initial framework preview.

package/dist/index.js

@@ -0,0 +1,1052 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// ../../packages/platform-contracts/src/ids.ts
+function asId(value) {
+  return value;
+}
+
+// ../../packages/model-gateway/src/index.ts
+var defaultDeepSeekProfile = {
+  id: asId("model-deepseek-default"),
+  providerId: asId("provider-deepseek"),
+  model: "deepseek-chat",
+  temperature: 0
+};
+var DeterministicMockModelGateway = class {
+  async *stream(request) {
+    yield { kind: "delta", text: `DeepSeek mock response: ${request.prompt}` };
+    yield {
+      kind: "usage",
+      inputTokens: await this.countTokens(request.prompt, request.profile),
+      outputTokens: 6
+    };
+    yield { kind: "done" };
+  }
+  async countTokens(text, _profile) {
+    return text.trim().length === 0 ? 0 : text.trim().split(/\s+/).length;
+  }
+};
+
+// ../../packages/runtime/src/index.ts
+var HeadlessAgentRuntime = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  disposed = false;
+  async startSession(request = {}) {
+    const sessionId = await this.deps.sessions.create({
+      workspaceRoot: request.workspaceRoot ?? "",
+      agentId: request.agentId ?? ""
+    });
+    await this.appendSessionEvent(sessionId, "session.started", { workspaceRoot: request.workspaceRoot ?? "" });
+    return sessionId;
+  }
+  async *runTurn(request) {
+    if (this.disposed) {
+      throw new Error("Runtime disposed");
+    }
+    const sessionId = request.sessionId ?? await this.startSession(request.agentId ? { agentId: request.agentId } : {});
+    const turnId = asId(`turn-${sessionId}`);
+    const agentDefinition = request.agentId ? (await this.deps.agents.listDefinitions()).find((definition) => definition.id === request.agentId) ?? await this.deps.agents.getDefault() : await this.deps.agents.getDefault();
+    const agent = await this.deps.agents.createInstance(agentDefinition.id, sessionId);
+    const trace = this.trace(sessionId, "runtime");
+    const started = {
+      kind: "turn.started",
+      sessionId,
+      turnId,
+      agentId: agent.definition.id,
+      trace,
+      data: { prompt: request.prompt, agentInstanceId: agent.id }
+    };
+    await this.recordRuntimeEvent(started);
+    yield started;
+    const graph = await this.deps.workflow.createGraph({ sessionId, prompt: request.prompt });
+    for await (const event of this.deps.workflow.runGraph(graph, { sessionId, prompt: request.prompt })) {
+      await this.recordRuntimeEvent(event);
+      yield event;
+    }
+    const busRecorded = {
+      kind: "bus.recorded",
+      sessionId,
+      turnId,
+      taskId: graph.taskId,
+      agentId: agent.definition.id,
+      trace,
+      data: {
+        topic: "runtime.event",
+        replayRecords: this.deps.bus.getReplayRecords(sessionId).length
+      }
+    };
+    await this.recordRuntimeEvent(busRecorded);
+    yield busRecorded;
+    const checkpoint = await this.deps.workflow.createCheckpoint(graph, { reason: "single-turn-start" });
+    await this.deps.sessions.snapshot(sessionId, { checkpointId: checkpoint.id, workflowId: graph.id });
+    const projection = await this.deps.context.project(sessionId, request.prompt);
+    const tools = (await this.deps.capabilities.listModelVisible()).map((manifest) => ({
+      id: manifest.id,
+      name: manifest.name,
+      version: manifest.version,
+      sideEffect: manifest.sideEffect,
+      permissions: manifest.permissions
+    }));
+    const modelEvents = this.deps.models.stream({
+      profile: defaultDeepSeekProfile,
+      prompt: projection.prompt,
+      tools
+    });
+    for await (const modelEvent of modelEvents) {
+      const runtimeEvent = await this.modelEventToRuntimeEvent(modelEvent, sessionId, turnId, agent.definition.id, trace);
+      if (runtimeEvent) {
+        await this.recordRuntimeEvent(runtimeEvent);
+        yield runtimeEvent;
+      }
+    }
+    const completed = {
+      kind: "turn.completed",
+      sessionId,
+      turnId,
+      taskId: graph.taskId,
+      agentId: agent.definition.id,
+      trace,
+      data: {
+        workflowId: graph.id,
+        checkpointId: checkpoint.id,
+        status: "completed"
+      }
+    };
+    await this.recordRuntimeEvent(completed);
+    yield completed;
+  }
+  async interrupt(sessionId, reason) {
+    await this.appendSessionEvent(sessionId, "runtime.interrupted", { reason });
+  }
+  async dispose() {
+    this.disposed = true;
+  }
+  async modelEventToRuntimeEvent(modelEvent, sessionId, turnId, agentId, trace) {
+    if (modelEvent.kind === "delta") {
+      return {
+        kind: "model.delta",
+        sessionId,
+        turnId,
+        agentId,
+        trace,
+        data: { text: modelEvent.text }
+      };
+    }
+    if (modelEvent.kind === "usage") {
+      await this.deps.usage.record({
+        sessionId,
+        inputTokens: modelEvent.inputTokens,
+        outputTokens: modelEvent.outputTokens,
+        costMicros: 0,
+        elapsedMs: 0
+      });
+      return {
+        kind: "usage.updated",
+        sessionId,
+        turnId,
+        agentId,
+        trace,
+        data: {
+          inputTokens: modelEvent.inputTokens,
+          outputTokens: modelEvent.outputTokens
+        }
+      };
+    }
+    if (modelEvent.kind === "error") {
+      return {
+        kind: "runtime.error",
+        sessionId,
+        turnId,
+        agentId,
+        trace,
+        data: {},
+        error: modelEvent.error
+      };
+    }
+    return void 0;
+  }
+  async recordRuntimeEvent(event) {
+    await this.appendSessionEvent(event.sessionId, event.kind, event.data);
+    await this.deps.bus.publish(this.toBusEnvelope(event));
+    await this.deps.observability.emit({
+      kind: event.kind === "usage.updated" ? "usage" : "trace",
+      at: (/* @__PURE__ */ new Date(0)).toISOString(),
+      name: event.kind,
+      fields: event.data
+    });
+  }
+  async appendSessionEvent(sessionId, kind, payload) {
+    const events = await this.deps.sessions.events(sessionId);
+    const event = {
+      sessionId,
+      sequence: events.length + 1,
+      kind,
+      at: (/* @__PURE__ */ new Date(0)).toISOString(),
+      payload,
+      redaction: { class: "internal" }
+    };
+    await this.deps.sessions.append(event);
+  }
+  toBusEnvelope(event) {
+    return {
+      protocolVersion: "1",
+      schemaVersion: "1.0.0",
+      id: `bus-${event.kind}-${event.sessionId}`,
+      type: "event",
+      createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      trace: event.trace,
+      redaction: { class: "internal" },
+      compatibility: { schemaVersion: "1.0.0" },
+      payload: {
+        kind: event.kind,
+        data: event.data
+      },
+      topic: { name: "runtime.event", owner: "runtime", trustBoundary: "core" },
+      producer: "runtime",
+      correlationId: event.trace.correlationId,
+      sessionId: event.sessionId,
+      replayable: true
+    };
+  }
+  trace(sessionId, scope) {
+    return {
+      traceId: asId(`trace-${scope}-${sessionId}`),
+      spanId: asId(`span-${scope}-${sessionId}`),
+      correlationId: asId(`corr-${scope}-${sessionId}`),
+      sessionId
+    };
+  }
+};
+function createHeadlessRuntime(deps) {
+  return new HeadlessAgentRuntime(deps);
+}
+
+// ../../packages/testing-regression/src/harness/index.ts
+var DeterministicRegressionHarness = class {
+  async normalize(trace) {
+    return {
+      ...trace,
+      protocol: [...trace.protocol],
+      bus: [...trace.bus],
+      runtime: [...trace.runtime],
+      sessions: [...trace.sessions]
+    };
+  }
+  async replay(trace) {
+    const failures = [];
+    if (!trace.name) failures.push("missing trace name");
+    if (trace.runtime.length === 0) failures.push("runtime trace is empty");
+    return { ok: failures.length === 0, failures };
+  }
+  async assertSemantic(trace, assertion) {
+    const expectedKind = assertion.expectedKind;
+    if (typeof expectedKind === "string" && !trace.runtime.some((event) => event.kind === expectedKind)) {
+      return { ok: false, failures: [`missing runtime event kind ${expectedKind}`] };
+    }
+    return { ok: true, failures: [] };
+  }
+};
+
+// ../../packages/agent-management/src/index.ts
+var defaultAgent = {
+  id: asId("agent-default"),
+  name: "default",
+  version: "1.0.0",
+  source: "built-in",
+  modelProfileId: asId("model-deepseek-default"),
+  promptProfile: "coding-agent",
+  scopes: {
+    capabilities: ["*"],
+    context: ["workspace", "session"],
+    memory: ["working", "session", "project"],
+    policy: ["default"],
+    skills: ["trusted"],
+    commands: ["*"],
+    hooks: ["trusted"]
+  }
+};
+var InMemoryAgentManager = class {
+  definitions = /* @__PURE__ */ new Map([[defaultAgent.id, defaultAgent]]);
+  instances = /* @__PURE__ */ new Map();
+  async register(definition) {
+    if (this.definitions.has(definition.id)) {
+      throw new Error(`Agent definition already registered: ${definition.id}`);
+    }
+    this.definitions.set(definition.id, definition);
+  }
+  async getDefault() {
+    return defaultAgent;
+  }
+  async createInstance(definitionId, sessionId) {
+    const definition = this.definitions.get(definitionId);
+    if (!definition) {
+      throw new Error(`Unknown agent definition: ${definitionId}`);
+    }
+    const instance = {
+      id: asId(`agent-instance-${sessionId}`),
+      definition,
+      sessionId,
+      status: "running"
+    };
+    this.instances.set(instance.id, instance);
+    return instance;
+  }
+  async getInstance(instanceId) {
+    return this.instances.get(instanceId);
+  }
+  async listDefinitions() {
+    return [...this.definitions.values()];
+  }
+};
+
+// ../../packages/capability-registry/src/index.ts
+var InMemoryCapabilityRegistry = class {
+  manifests = /* @__PURE__ */ new Map();
+  executors = /* @__PURE__ */ new Map();
+  async register(manifest, executor) {
+    if (this.manifests.has(manifest.id)) throw new Error(`Capability already registered: ${manifest.id}`);
+    this.manifests.set(manifest.id, manifest);
+    if (executor) this.executors.set(manifest.id, executor);
+  }
+  async get(id) {
+    return this.manifests.get(id);
+  }
+  async listModelVisible() {
+    return [...this.manifests.values()].filter((manifest) => manifest.enabled && manifest.trust !== "untrusted");
+  }
+  async execute(id, input) {
+    const executor = this.executors.get(id);
+    if (!executor) {
+      return { ok: false, error: { code: "CAPABILITY_NOT_EXECUTABLE", message: String(id), retryable: false, redaction: { class: "public" } } };
+    }
+    return executor(input);
+  }
+};
+
+// ../../packages/code-intelligence/src/index.ts
+var NullCodeIntelligenceService = class {
+  async diagnostics(_root) {
+    return [];
+  }
+  async symbols(query) {
+    return query ? [{ name: query, path: "<memory>", line: 1 }] : [];
+  }
+  async definitions(symbol) {
+    return symbol ? [{ name: symbol, path: "<memory>", line: 1 }] : [];
+  }
+  async invalidate(_path) {
+  }
+};
+
+// ../../packages/command-system/src/index.ts
+var InMemoryCommandSystem = class {
+  manifests = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  async register(manifest, handler) {
+    this.manifests.set(manifest.id, manifest);
+    this.aliases.set(manifest.name, manifest.id);
+    for (const alias of manifest.aliases) this.aliases.set(alias, manifest.id);
+    if (handler) this.handlers.set(manifest.id, handler);
+  }
+  async invoke(nameOrAlias, input) {
+    const id = this.aliases.get(nameOrAlias);
+    const handler = id ? this.handlers.get(id) : void 0;
+    if (!handler) {
+      return { ok: false, error: { code: "COMMAND_NOT_FOUND", message: nameOrAlias, retryable: false, redaction: { class: "public" } } };
+    }
+    return handler(input);
+  }
+  async help() {
+    return [...this.manifests.values()];
+  }
+};
+
+// ../../packages/communication-protocol/src/index.ts
+var PipelineProtocolRouter = class {
+  constructor(stages, handler) {
+    this.stages = stages;
+    this.handler = handler;
+  }
+  stages;
+  handler;
+  async route(envelope) {
+    let current = envelope;
+    for (const stage of this.stages) {
+      current = await stage.handle(current);
+    }
+    return this.handler(current);
+  }
+};
+
+// ../../packages/concurrency-orchestration/src/index.ts
+var DeterministicScheduler = class {
+  taskEvents = [];
+  lockChains = /* @__PURE__ */ new Map();
+  cancelled = /* @__PURE__ */ new Map();
+  async run(scope, work) {
+    const cancelledReason = this.cancelled.get(scope.id);
+    if (cancelledReason) {
+      this.record(scope.id, "cancelled", cancelledReason);
+      throw new Error(`Task cancelled: ${cancelledReason}`);
+    }
+    if (scope.deadlineMs !== void 0 && scope.deadlineMs <= 0) {
+      this.record(scope.id, "timed-out", "deadline elapsed before task start");
+      throw new Error("Task deadline elapsed");
+    }
+    this.record(scope.id, "running");
+    try {
+      const result = await work();
+      const cancelledAfterWork = this.cancelled.get(scope.id);
+      if (cancelledAfterWork) {
+        this.record(scope.id, "cancelled", cancelledAfterWork);
+        throw new Error(`Task cancelled: ${cancelledAfterWork}`);
+      }
+      this.record(scope.id, "completed");
+      return result;
+    } catch (error) {
+      if (this.cancelled.has(scope.id)) throw error;
+      this.record(scope.id, "failed", error instanceof Error ? error.message : "unknown");
+      throw error;
+    }
+  }
+  async withLock(lock, work) {
+    const key = `${lock.kind}:${lock.key}`;
+    const previous = this.lockChains.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    this.lockChains.set(
+      key,
+      previous.then(() => current)
+    );
+    await previous;
+    try {
+      return await work();
+    } finally {
+      release();
+      if (this.lockChains.get(key) === current) {
+        this.lockChains.delete(key);
+      }
+    }
+  }
+  async cancel(taskId, reason) {
+    this.cancelled.set(taskId, reason);
+    this.record(taskId, "cancelled", reason);
+  }
+  events() {
+    return [...this.taskEvents];
+  }
+  record(taskId, status, reason) {
+    this.taskEvents.push({
+      taskId,
+      status,
+      at: (/* @__PURE__ */ new Date(0)).toISOString(),
+      ...reason ? { reason } : {}
+    });
+  }
+};
+
+// ../../packages/config/src/index.ts
+var InMemoryConfigStore = class {
+  values = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.values.get(key);
+  }
+  async set(key, value) {
+    this.values.set(key, value);
+  }
+  async profile() {
+    return {
+      name: "default",
+      values: Object.fromEntries(this.values)
+    };
+  }
+};
+
+// ../../packages/context-engine/src/index.ts
+var InMemoryContextEngine = class {
+  nodes = /* @__PURE__ */ new Map();
+  async addNode(sessionId, node) {
+    const current = this.nodes.get(sessionId) ?? [];
+    current.push(node);
+    this.nodes.set(sessionId, current);
+  }
+  async project(sessionId, prompt) {
+    const nodes = this.nodes.get(sessionId) ?? [];
+    return {
+      prompt: [...nodes.map((node) => node.content), prompt].join("\n"),
+      nodes
+    };
+  }
+};
+
+// ../../packages/credential-auth-management/src/index.ts
+var FakeCredentialManager = class {
+  records = /* @__PURE__ */ new Map();
+  async resolve(ref) {
+    return this.records.get(ref);
+  }
+  async put(record) {
+    this.records.set(record.ref, record);
+  }
+  redact(value) {
+    return value.length <= 4 ? "****" : `${value.slice(0, 2)}****${value.slice(-2)}`;
+  }
+};
+
+// ../../packages/distribution-update-management/src/index.ts
+var currentRelease = {
+  version: "0.1.0",
+  channel: "dev",
+  signedMetadata: "development-unsigned",
+  compatibility: ["framework-0.1"]
+};
+var StaticDistributionUpdateManager = class {
+  async current() {
+    return currentRelease;
+  }
+  async checkForUpdate() {
+    return void 0;
+  }
+  async catalogs() {
+    return [];
+  }
+};
+
+// ../../packages/evolution-engine/src/index.ts
+var InMemoryEvolutionEngine = class {
+  gates = /* @__PURE__ */ new Map();
+  migrations = [];
+  async isEnabled(gate) {
+    return this.gates.get(gate)?.enabled ?? false;
+  }
+  async setGate(gate) {
+    this.gates.set(gate.name, gate);
+  }
+  async checkCompatibility(subject) {
+    return typeof subject.schemaVersion === "string" ? [] : ["missing schemaVersion"];
+  }
+  async recordMigration(record) {
+    this.migrations.push(record);
+  }
+};
+
+// ../../packages/extension-system/src/index.ts
+var InMemoryExtensionManager = class {
+  manifests = /* @__PURE__ */ new Map();
+  async load(manifest) {
+    if (manifest.trust === "untrusted") throw new Error("Untrusted extensions are disabled by default");
+    this.manifests.set(manifest.id, manifest);
+  }
+  async list() {
+    return [...this.manifests.values()];
+  }
+  async contributions(point) {
+    return [...this.manifests.values()].map((manifest) => manifest.contributions[point]).filter((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+  }
+};
+
+// ../../packages/hook-system/src/index.ts
+var InMemoryHookSystem = class {
+  manifests = [];
+  handlers = /* @__PURE__ */ new Map();
+  async register(manifest, handler) {
+    this.manifests.push(manifest);
+    if (handler) this.handlers.set(manifest.id, handler);
+  }
+  async run(point, input) {
+    const hooks = this.manifests.filter((manifest) => manifest.point === point).sort((a, b) => a.order - b.order);
+    const results = [];
+    for (const hook of hooks) {
+      const handler = this.handlers.get(hook.id);
+      if (handler) results.push(await handler(input));
+    }
+    return results;
+  }
+};
+
+// ../../packages/mcp-gateway/src/index.ts
+var FakeMcpGateway = class {
+  servers = /* @__PURE__ */ new Map();
+  async connect(manifest) {
+    if (manifest.trust === "untrusted") throw new Error("Untrusted MCP servers are disabled by default");
+    this.servers.set(manifest.id, manifest);
+  }
+  async listTools(namespace) {
+    return [...this.servers.values()].filter((server) => !namespace || server.namespace === namespace).map((server) => ({ namespace: server.namespace, name: "fake.tool" }));
+  }
+  async callTool(namespace, name, input) {
+    return { namespace, name, input, ok: true };
+  }
+};
+
+// ../../packages/memory-cache-management/src/index.ts
+var InMemoryMemoryManager = class {
+  entries = [];
+  async put(entry) {
+    this.entries.push(entry);
+  }
+  async query(scope) {
+    return this.entries.filter((entry) => entry.scope === scope);
+  }
+};
+var InMemoryCacheManager = class {
+  entries = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.entries.get(key);
+  }
+  async set(entry) {
+    this.entries.set(entry.key, entry);
+  }
+  async invalidate(namespace) {
+    let count = 0;
+    for (const [key, entry] of this.entries) {
+      if (entry.namespace === namespace) {
+        this.entries.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+};
+
+// ../../packages/observability/src/index.ts
+var InMemoryObservabilitySink = class {
+  events = [];
+  async emit(event) {
+    this.events.push(event);
+  }
+  async drain() {
+    return [...this.events];
+  }
+};
+
+// ../../packages/platform-abstraction/src/index.ts
+import { readFile as fsReadFile, writeFile as fsWriteFile, readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { spawn } from "node:child_process";
+var NodePlatformRuntime = class {
+  os;
+  constructor(os = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "macos" : "linux") {
+    this.os = os;
+  }
+  resolvePath(...parts) {
+    return resolve(...parts);
+  }
+  async readFile(path) {
+    return fsReadFile(path, "utf8");
+  }
+  async writeFile(path, content) {
+    await fsWriteFile(path, content, "utf8");
+  }
+  async findFiles(pattern, root) {
+    const files = [];
+    await walk(root, files);
+    return files.filter((file) => file.includes(pattern));
+  }
+  async searchText(pattern, root) {
+    const files = [];
+    await walk(root, files);
+    const results = [];
+    for (const file of files) {
+      const content = await fsReadFile(file, "utf8").catch(() => "");
+      const lines = content.split(/\r?\n/);
+      lines.forEach((line, index) => {
+        if (line.includes(pattern)) {
+          results.push({
+            path: file,
+            line: index + 1,
+            text: line,
+            engine: "js",
+            fallbackReason: "deterministic-js-fallback"
+          });
+        }
+      });
+    }
+    return results;
+  }
+  async runProcess(command, args, options = {}) {
+    return new Promise((resolvePromise) => {
+      const child = spawn(command, [...args], {
+        cwd: typeof options.cwd === "string" ? options.cwd : void 0,
+        shell: false
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += String(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += String(chunk);
+      });
+      child.on("close", (exitCode) => resolvePromise({ exitCode: exitCode ?? 0, stdout, stderr }));
+      child.on("error", (error) => resolvePromise({ exitCode: 1, stdout, stderr: error.message }));
+    });
+  }
+  async availability() {
+    return {
+      os: this.os,
+      searchFallbacks: ["rg", "grep", "select-string", "js"]
+    };
+  }
+};
+var FakePlatformRuntime = class extends NodePlatformRuntime {
+  constructor(os = "fake") {
+    super(os);
+  }
+  async runProcess(command, args) {
+    return {
+      exitCode: 0,
+      stdout: JSON.stringify({ command, args }),
+      stderr: ""
+    };
+  }
+};
+async function walk(root, files) {
+  for (const entry of await readdir(root, { withFileTypes: true }).catch(() => [])) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) {
+      await walk(path, files);
+    } else {
+      files.push(path);
+    }
+  }
+}
+
+// ../../packages/plugin-system/src/index.ts
+var InMemoryPluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  async install(manifest) {
+    this.plugins.set(manifest.id, manifest);
+    return { added: manifest.permissions, removed: [] };
+  }
+  async uninstall(id) {
+    this.plugins.delete(id);
+  }
+  async list() {
+    return [...this.plugins.values()];
+  }
+};
+
+// ../../packages/policy-sandbox/src/index.ts
+var DefaultPolicyEngine = class {
+  async decide(request) {
+    if (request.action.includes("delete") || request.action.includes("secret")) {
+      return { action: "ask", reason: "Potentially sensitive action requires approval" };
+    }
+    if (request.resource.includes("untrusted")) {
+      return { action: "quarantine", reason: "Untrusted resource" };
+    }
+    return { action: "allow", reason: "Default development policy" };
+  }
+};
+var HeadlessApprovalBroker = class {
+  constructor(defaultApproved = false) {
+    this.defaultApproved = defaultApproved;
+  }
+  defaultApproved;
+  async requestApproval(request) {
+    return {
+      approved: this.defaultApproved,
+      reason: this.defaultApproved ? `Approved: ${request.prompt}` : `Denied by headless default: ${request.prompt}`
+    };
+  }
+};
+var DevelopmentSandboxRuntime = class {
+  async *run(request) {
+    yield {
+      kind: "recorded",
+      mode: "development",
+      metadata: {
+        command: request.command,
+        args: request.args,
+        controls: request.controls,
+        enforcement: "not-production"
+      }
+    };
+  }
+};
+
+// ../../packages/remote-runtime-connectivity/src/index.ts
+var NoopRemoteRuntimeConnectivity = class {
+  bindings = /* @__PURE__ */ new Map();
+  async bind(binding) {
+    this.bindings.set(binding.id, binding);
+  }
+  async reconnect(id) {
+    return this.bindings.get(id);
+  }
+  async cancelRemote(_id, _reason) {
+  }
+};
+
+// ../../packages/runtime-message-bus/src/index.ts
+var InMemoryRuntimeMessageBus = class {
+  records = [];
+  subscribers = /* @__PURE__ */ new Map();
+  maxRecords;
+  constructor(options = {}) {
+    this.maxRecords = options.maxRecords ?? 1e3;
+  }
+  async publish(envelope) {
+    if (this.records.length >= this.maxRecords) {
+      throw new Error("BUS_BACKPRESSURE");
+    }
+    if (envelope.replayable) {
+      this.records.push(envelope);
+    }
+    for (const listener of this.subscribers.get(envelope.topic.name) ?? []) {
+      listener(envelope);
+    }
+  }
+  async *subscribe(subscription) {
+    const queue = [];
+    const listener = (envelope) => queue.push(envelope);
+    const listeners = this.subscribers.get(subscription.topic) ?? [];
+    listeners.push(listener);
+    this.subscribers.set(subscription.topic, listeners);
+    try {
+      while (true) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else {
+          await new Promise((resolve2) => setTimeout(resolve2, 0));
+        }
+      }
+    } finally {
+      const current = this.subscribers.get(subscription.topic) ?? [];
+      this.subscribers.set(
+        subscription.topic,
+        current.filter((item) => item !== listener)
+      );
+    }
+  }
+  getReplayRecords(sessionId) {
+    return sessionId ? this.records.filter((record) => record.sessionId === sessionId) : [...this.records];
+  }
+};
+
+// ../../packages/session-store/src/index.ts
+var InMemorySessionStore = class {
+  next = 1;
+  eventsBySession = /* @__PURE__ */ new Map();
+  async create(_metadata = {}) {
+    const id = asId(`session-${this.next++}`);
+    this.eventsBySession.set(id, []);
+    return id;
+  }
+  async append(event) {
+    const events = this.eventsBySession.get(event.sessionId) ?? [];
+    events.push(event);
+    this.eventsBySession.set(event.sessionId, events);
+  }
+  async events(sessionId) {
+    return [...this.eventsBySession.get(sessionId) ?? []];
+  }
+  async snapshot(sessionId, payload) {
+    return {
+      sessionId,
+      eventCount: this.eventsBySession.get(sessionId)?.length ?? 0,
+      checkpointId: `checkpoint-${sessionId}`,
+      payload
+    };
+  }
+};
+
+// ../../packages/skill-system/src/index.ts
+var InMemorySkillSystem = class {
+  manifests = /* @__PURE__ */ new Map();
+  async register(manifest) {
+    this.manifests.set(manifest.id, manifest);
+  }
+  async activate(name, _context) {
+    return [...this.manifests.values()].find((manifest) => manifest.name === name && manifest.trust !== "untrusted");
+  }
+  async list() {
+    return [...this.manifests.values()];
+  }
+};
+
+// ../../packages/usage-budget-management/src/index.ts
+var InMemoryUsageBudgetManager = class {
+  records = [];
+  async record(record) {
+    this.records.push(record);
+  }
+  async check() {
+    return { allowed: true };
+  }
+  async total(sessionId) {
+    return this.records.filter((record) => record.sessionId === sessionId).reduce(
+      (acc, record) => ({
+        sessionId,
+        inputTokens: acc.inputTokens + record.inputTokens,
+        outputTokens: acc.outputTokens + record.outputTokens,
+        costMicros: acc.costMicros + record.costMicros,
+        elapsedMs: acc.elapsedMs + record.elapsedMs
+      }),
+      { sessionId, inputTokens: 0, outputTokens: 0, costMicros: 0, elapsedMs: 0 }
+    );
+  }
+};
+
+// ../../packages/workflow-orchestration/src/index.ts
+var SingleTurnWorkflowOrchestrator = class {
+  async createGraph(request) {
+    const step = {
+      id: asId("step-model-response"),
+      name: "model-response",
+      dependsOn: [],
+      status: "pending"
+    };
+    return {
+      id: asId(`workflow-${request.sessionId}`),
+      taskId: asId(`task-${request.sessionId}`),
+      steps: [step]
+    };
+  }
+  async *runGraph(graph, request) {
+    yield {
+      kind: "workflow.step",
+      sessionId: request.sessionId,
+      taskId: graph.taskId,
+      trace: {
+        traceId: asId(`trace-${graph.id}`),
+        spanId: asId(`span-${graph.id}`),
+        correlationId: asId(`corr-${graph.id}`),
+        sessionId: request.sessionId
+      },
+      data: {
+        workflowId: graph.id,
+        stepId: graph.steps[0]?.id ?? "",
+        status: "running"
+      }
+    };
+  }
+  async createCheckpoint(graph) {
+    return {
+      id: `checkpoint-${graph.id}`,
+      sessionId: asId(String(graph.taskId).replace("task-", "")),
+      workflowId: graph.id,
+      createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      metadata: { taskId: graph.taskId }
+    };
+  }
+  async validateGraph(graph) {
+    return graph.steps.length === 0 ? ["workflow graph must contain at least one step"] : [];
+  }
+};
+
+// ../../packages/workspace-state-management/src/index.ts
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+var InMemoryWorkspaceStateManager = class {
+  transactions = [];
+  async identify(roots) {
+    return {
+      id: asId(`workspace-${createHash("sha1").update(roots.join("|")).digest("hex").slice(0, 8)}`),
+      roots,
+      trusted: true
+    };
+  }
+  async snapshot(path) {
+    const content = await readFile(path, "utf8").catch(() => "");
+    return {
+      path,
+      contentHash: createHash("sha1").update(content).digest("hex"),
+      capturedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+    };
+  }
+  async transact(transaction) {
+    this.transactions.push(transaction);
+  }
+};
+
+// ../../packages/testing-regression/src/fakes/index.ts
+function createDeterministicRuntimeDependencies() {
+  const runtimePlaceholder = async () => ({
+    envelope: {},
+    ok: false,
+    error: {
+      code: "ROUTER_NOT_BOUND",
+      message: "Protocol router is not bound to runtime in deterministic dependencies",
+      retryable: false,
+      redaction: { class: "public" }
+    }
+  });
+  return {
+    protocol: new PipelineProtocolRouter([], runtimePlaceholder),
+    bus: new InMemoryRuntimeMessageBus(),
+    workflow: new SingleTurnWorkflowOrchestrator(),
+    concurrency: new DeterministicScheduler(),
+    agents: new InMemoryAgentManager(),
+    models: new DeterministicMockModelGateway(),
+    capabilities: new InMemoryCapabilityRegistry(),
+    commands: new InMemoryCommandSystem(),
+    skills: new InMemorySkillSystem(),
+    hooks: new InMemoryHookSystem(),
+    mcp: new FakeMcpGateway(),
+    plugins: new InMemoryPluginManager(),
+    extensions: new InMemoryExtensionManager(),
+    context: new InMemoryContextEngine(),
+    memory: new InMemoryMemoryManager(),
+    cache: new InMemoryCacheManager(),
+    credentials: new FakeCredentialManager(),
+    usage: new InMemoryUsageBudgetManager(),
+    workspaceState: new InMemoryWorkspaceStateManager(),
+    policy: new DefaultPolicyEngine(),
+    approvals: new HeadlessApprovalBroker(false),
+    sandbox: new DevelopmentSandboxRuntime(),
+    sessions: new InMemorySessionStore(),
+    platform: new FakePlatformRuntime(),
+    evolution: new InMemoryEvolutionEngine(),
+    codeIntelligence: new NullCodeIntelligenceService(),
+    remote: new NoopRemoteRuntimeConnectivity(),
+    distribution: new StaticDistributionUpdateManager(),
+    config: new InMemoryConfigStore(),
+    observability: new InMemoryObservabilitySink(),
+    regression: new DeterministicRegressionHarness()
+  };
+}
+
+// src/index.ts
+function parseCliArgs(args) {
+  const promptIndex = args.indexOf("-p");
+  const prompt = promptIndex >= 0 ? args[promptIndex + 1] ?? "" : args.join(" ");
+  const outputFlagIndex = args.indexOf("--output");
+  const output = outputFlagIndex >= 0 && args[outputFlagIndex + 1] === "stream-json" ? "stream-json" : "text";
+  return { prompt, output };
+}
+function renderText(event) {
+  if (event.kind === "model.delta") return String(event.data.text ?? "");
+  if (event.kind === "turn.completed") return "[completed]";
+  return `[${event.kind}]`;
+}
+function renderStreamJson(event) {
+  return JSON.stringify(event);
+}
+async function runCli(args, write = console.log) {
+  const options = parseCliArgs(args);
+  const runtime = createHeadlessRuntime(createDeterministicRuntimeDependencies());
+  for await (const event of runtime.runTurn({ prompt: options.prompt })) {
+    write(options.output === "stream-json" ? renderStreamJson(event) : renderText(event));
+  }
+  await runtime.dispose();
+}
+var entryPath = process.argv[1]?.replace(/\\/g, "/") ?? "";
+if (entryPath.endsWith("/src/apps/cli/src/index.ts") || entryPath.endsWith("/src/apps/cli/src/index.js")) {
+  await runCli(process.argv.slice(2));
+}
+export {
+  parseCliArgs,
+  renderStreamJson,
+  renderText,
+  runCli
+};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "deekseek-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node22 --outfile=dist/index.js --banner:js=\"#!/usr/bin/env node\""
+  },
+  "dependencies": {},
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "deepseek": "./dist/index.js"
+  }
+}