@nextclaw/kernel 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NextClaw contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,286 @@
+import { NcpMessage } from "@nextclaw/ncp";
+
+//#region src/types/entity-ids.types.d.ts
+type AgentId = string;
+type TaskId = string;
+type SessionId = string;
+type ToolId = string;
+type SkillId = string;
+type LlmProviderId = string;
+type AutomationId = string;
+type ChannelId = string;
+//#endregion
+//#region src/types/agent.types.d.ts
+type AgentRecord = {
+  id: AgentId;
+  name: string;
+  description?: string;
+  defaultProviderId?: LlmProviderId | null;
+  enabledSkillIds: SkillId[];
+  enabledToolIds: ToolId[];
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/managers/agent.manager.d.ts
+declare class AgentManager {
+  readonly listAgents: () => never;
+  readonly getAgent: (agentId: AgentId) => never;
+  readonly requireAgent: (agentId: AgentId) => never;
+  readonly saveAgent: (agent: AgentRecord) => never;
+  readonly removeAgent: (agentId: AgentId) => never;
+  readonly attachSkill: (agentId: AgentId, skillId: SkillId) => never;
+  readonly detachSkill: (agentId: AgentId, skillId: SkillId) => never;
+  readonly attachTool: (agentId: AgentId, toolId: ToolId) => never;
+  readonly detachTool: (agentId: AgentId, toolId: ToolId) => never;
+}
+//#endregion
+//#region src/types/automation.types.d.ts
+type AutomationTrigger = {
+  kind: "cron";
+  expression: string;
+} | {
+  kind: "manual";
+} | {
+  kind: "event";
+  event: string;
+};
+type AutomationRecord = {
+  id: AutomationId;
+  name: string;
+  enabled: boolean;
+  trigger: AutomationTrigger;
+  agentId: AgentId;
+  sessionId?: SessionId | null;
+  inputTemplate?: unknown;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/managers/automation.manager.d.ts
+declare class AutomationManager {
+  readonly listAutomations: () => never;
+  readonly getAutomation: (automationId: AutomationId) => never;
+  readonly requireAutomation: (automationId: AutomationId) => never;
+  readonly saveAutomation: (automation: AutomationRecord) => never;
+  readonly enableAutomation: (automationId: AutomationId) => never;
+  readonly disableAutomation: (automationId: AutomationId) => never;
+  readonly deleteAutomation: (automationId: AutomationId) => never;
+}
+//#endregion
+//#region src/types/channel.types.d.ts
+type ChannelDirection = "inbound" | "outbound" | "bidirectional";
+type ChannelRecord = {
+  id: ChannelId;
+  name: string;
+  enabled: boolean;
+  direction: ChannelDirection;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/managers/channel.manager.d.ts
+declare class ChannelManager {
+  readonly listChannels: () => never;
+  readonly getChannel: (channelId: ChannelId) => never;
+  readonly requireChannel: (channelId: ChannelId) => never;
+  readonly saveChannel: (channel: ChannelRecord) => never;
+  readonly enableChannel: (channelId: ChannelId) => never;
+  readonly disableChannel: (channelId: ChannelId) => never;
+}
+//#endregion
+//#region src/types/context.types.d.ts
+type ContextRecord = {
+  sessionId: SessionId;
+  taskId?: TaskId | null;
+  agentId?: AgentId | null;
+  workspace?: string | null;
+  memoryRefs: string[];
+  selectedSkillIds: SkillId[];
+  selectedToolIds: ToolId[];
+  selectedProviderId?: LlmProviderId | null;
+  variables: Record<string, unknown>;
+};
+//#endregion
+//#region src/types/task.types.d.ts
+type TaskStatus = "pending" | "running" | "blocked" | "completed" | "failed" | "cancelled";
+type TaskRecord = {
+  id: TaskId;
+  title: string;
+  status: TaskStatus;
+  agentId: AgentId;
+  sessionId: SessionId;
+  input: unknown;
+  output?: unknown;
+  error?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/types/session.types.d.ts
+type SessionMessage = NcpMessage;
+type SessionRecord = {
+  id: SessionId;
+  title?: string;
+  agentId?: AgentId | null;
+  taskIds: TaskId[];
+  contextVersion: number;
+  createdAt: string;
+  updatedAt: string;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/managers/session.manager.d.ts
+declare class SessionManager {
+  readonly listSessions: () => never;
+  readonly getSession: (sessionId: SessionId) => never;
+  readonly requireSession: (sessionId: SessionId) => never;
+  readonly createSession: (input?: {
+    title?: string;
+    agentId?: AgentId | null;
+    metadata?: Record<string, unknown>;
+  }) => never;
+  readonly saveSession: (session: SessionRecord) => never;
+  readonly appendMessage: (sessionId: SessionId, message: SessionMessage) => never;
+  readonly attachTask: (sessionId: SessionId, taskId: TaskId) => never;
+  readonly closeSession: (sessionId: SessionId) => never;
+}
+//#endregion
+//#region src/managers/context-builder.manager.d.ts
+declare class ContextBuilder {
+  private readonly sessions;
+  constructor(sessions: SessionManager);
+  readonly build: (input: {
+    sessionId: SessionId;
+    task?: TaskRecord | null;
+    agent: AgentRecord;
+  }) => ContextRecord;
+}
+//#endregion
+//#region src/types/llm-provider.types.d.ts
+type LlmProviderRecord = {
+  id: LlmProviderId;
+  name: string;
+  modelIds: string[];
+  enabled: boolean;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/managers/llm-provider.manager.d.ts
+declare class LlmProviderManager {
+  readonly listProviders: () => never;
+  readonly getProvider: (providerId: LlmProviderId) => never;
+  readonly requireProvider: (providerId: LlmProviderId) => never;
+  readonly saveProvider: (provider: LlmProviderRecord) => never;
+  readonly enableProvider: (providerId: LlmProviderId) => never;
+  readonly disableProvider: (providerId: LlmProviderId) => never;
+  readonly selectProvider: (input: {
+    agent: AgentRecord;
+    context: ContextRecord;
+  }) => never;
+}
+//#endregion
+//#region src/types/skill.types.d.ts
+type SkillRecord = {
+  id: SkillId;
+  name: string;
+  description: string;
+  toolIds: ToolId[];
+  enabled: boolean;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/managers/skill.manager.d.ts
+declare class SkillManager {
+  readonly listSkills: () => never;
+  readonly getSkill: (skillId: SkillId) => never;
+  readonly requireSkill: (skillId: SkillId) => never;
+  readonly saveSkill: (skill: SkillRecord) => never;
+  readonly enableSkill: (skillId: SkillId) => never;
+  readonly disableSkill: (skillId: SkillId) => never;
+  readonly resolveSkills: (skillIds: SkillId[]) => never;
+}
+//#endregion
+//#region src/managers/task.manager.d.ts
+declare class TaskManager {
+  readonly listTasks: () => never;
+  readonly getTask: (taskId: TaskId) => never;
+  readonly requireTask: (taskId: TaskId) => never;
+  readonly createTask: (input: {
+    title: string;
+    agentId: AgentId;
+    sessionId: SessionId;
+    input: unknown;
+    metadata?: Record<string, unknown>;
+  }) => never;
+  readonly saveTask: (task: TaskRecord) => never;
+  readonly updateTaskStatus: (taskId: TaskId, status: TaskStatus) => never;
+  readonly completeTask: (taskId: TaskId, output: unknown) => never;
+  readonly failTask: (taskId: TaskId, error: string) => never;
+  readonly cancelTask: (taskId: TaskId) => never;
+}
+//#endregion
+//#region src/types/tool.types.d.ts
+type ToolRecord = {
+  id: ToolId;
+  name: string;
+  description: string;
+  inputSchema?: Record<string, unknown>;
+  enabled: boolean;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/managers/tool.manager.d.ts
+declare class ToolManager {
+  readonly listTools: () => never;
+  readonly getTool: (toolId: ToolId) => never;
+  readonly requireTool: (toolId: ToolId) => never;
+  readonly saveTool: (tool: ToolRecord) => never;
+  readonly enableTool: (toolId: ToolId) => never;
+  readonly disableTool: (toolId: ToolId) => never;
+  readonly resolveTools: (toolIds: ToolId[]) => never;
+}
+//#endregion
+//#region src/types/nextclaw-kernel.types.d.ts
+type NextclawKernelRunMetadata = {
+  agentId?: AgentId;
+  model?: string;
+  skills?: SkillId[];
+};
+type NextclawKernelRunInput = {
+  sessionId: SessionId;
+  messages: NcpMessage[];
+  metadata?: NextclawKernelRunMetadata;
+  extra?: Record<string, unknown>;
+};
+type NextclawKernelRun = {
+  taskId: TaskId;
+};
+//#endregion
+//#region src/app/nextclaw-kernel.d.ts
+type NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput> = {
+  gateway: (input: TGatewayInput) => Promise<void>;
+  ui: (input: TUiInput) => Promise<void>;
+  start: (input: TStartInput) => Promise<void>;
+  restart: (input: TStartInput) => Promise<void>;
+  serve: (input: TStartInput) => Promise<void>;
+  stop: () => Promise<void>;
+};
+declare class NextclawKernelControlManager<TGatewayInput, TUiInput, TStartInput> {
+  private runtimeControl;
+  readonly installRuntimeControl: (runtimeControl: NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput>) => void;
+  readonly requireRuntimeControl: () => NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput>;
+}
+declare class NextclawKernel<TGatewayInput = unknown, TUiInput = unknown, TStartInput = unknown> {
+  readonly agents: AgentManager;
+  readonly tasks: TaskManager;
+  readonly sessions: SessionManager;
+  readonly contextBuilder: ContextBuilder;
+  readonly control: NextclawKernelControlManager<TGatewayInput, TUiInput, TStartInput>;
+  readonly tools: ToolManager;
+  readonly skills: SkillManager;
+  readonly llmProviders: LlmProviderManager;
+  readonly automation: AutomationManager;
+  readonly channels: ChannelManager;
+  readonly run: (input: NextclawKernelRunInput) => NextclawKernelRun;
+}
+//#endregion
+export { AgentId, AgentManager, AgentRecord, AutomationId, AutomationManager, AutomationRecord, AutomationTrigger, ChannelDirection, ChannelId, ChannelManager, ChannelRecord, ContextBuilder, ContextRecord, LlmProviderId, LlmProviderManager, LlmProviderRecord, NextclawKernel, NextclawKernelRun, NextclawKernelRunInput, NextclawKernelRunMetadata, SessionId, SessionManager, SessionMessage, SessionRecord, SkillId, SkillManager, SkillRecord, TaskId, TaskManager, TaskRecord, TaskStatus, ToolId, ToolManager, ToolRecord };

package/dist/index.js

@@ -0,0 +1,251 @@
+//#region src/managers/agent.manager.ts
+var AgentManager = class {
+	listAgents = () => {
+		throw new Error("AgentManager.listAgents is not implemented.");
+	};
+	getAgent = (agentId) => {
+		throw new Error("AgentManager.getAgent is not implemented.");
+	};
+	requireAgent = (agentId) => {
+		throw new Error("AgentManager.requireAgent is not implemented.");
+	};
+	saveAgent = (agent) => {
+		throw new Error("AgentManager.saveAgent is not implemented.");
+	};
+	removeAgent = (agentId) => {
+		throw new Error("AgentManager.removeAgent is not implemented.");
+	};
+	attachSkill = (agentId, skillId) => {
+		throw new Error("AgentManager.attachSkill is not implemented.");
+	};
+	detachSkill = (agentId, skillId) => {
+		throw new Error("AgentManager.detachSkill is not implemented.");
+	};
+	attachTool = (agentId, toolId) => {
+		throw new Error("AgentManager.attachTool is not implemented.");
+	};
+	detachTool = (agentId, toolId) => {
+		throw new Error("AgentManager.detachTool is not implemented.");
+	};
+};
+//#endregion
+//#region src/managers/automation.manager.ts
+var AutomationManager = class {
+	listAutomations = () => {
+		throw new Error("AutomationManager.listAutomations is not implemented.");
+	};
+	getAutomation = (automationId) => {
+		throw new Error("AutomationManager.getAutomation is not implemented.");
+	};
+	requireAutomation = (automationId) => {
+		throw new Error("AutomationManager.requireAutomation is not implemented.");
+	};
+	saveAutomation = (automation) => {
+		throw new Error("AutomationManager.saveAutomation is not implemented.");
+	};
+	enableAutomation = (automationId) => {
+		throw new Error("AutomationManager.enableAutomation is not implemented.");
+	};
+	disableAutomation = (automationId) => {
+		throw new Error("AutomationManager.disableAutomation is not implemented.");
+	};
+	deleteAutomation = (automationId) => {
+		throw new Error("AutomationManager.deleteAutomation is not implemented.");
+	};
+};
+//#endregion
+//#region src/managers/channel.manager.ts
+var ChannelManager = class {
+	listChannels = () => {
+		throw new Error("ChannelManager.listChannels is not implemented.");
+	};
+	getChannel = (channelId) => {
+		throw new Error("ChannelManager.getChannel is not implemented.");
+	};
+	requireChannel = (channelId) => {
+		throw new Error("ChannelManager.requireChannel is not implemented.");
+	};
+	saveChannel = (channel) => {
+		throw new Error("ChannelManager.saveChannel is not implemented.");
+	};
+	enableChannel = (channelId) => {
+		throw new Error("ChannelManager.enableChannel is not implemented.");
+	};
+	disableChannel = (channelId) => {
+		throw new Error("ChannelManager.disableChannel is not implemented.");
+	};
+};
+//#endregion
+//#region src/managers/context-builder.manager.ts
+var ContextBuilder = class {
+	constructor(sessions) {
+		this.sessions = sessions;
+	}
+	build = (input) => {
+		this.sessions;
+		throw new Error("ContextBuilder.build is not implemented.");
+	};
+};
+//#endregion
+//#region src/managers/llm-provider.manager.ts
+var LlmProviderManager = class {
+	listProviders = () => {
+		throw new Error("LlmProviderManager.listProviders is not implemented.");
+	};
+	getProvider = (providerId) => {
+		throw new Error("LlmProviderManager.getProvider is not implemented.");
+	};
+	requireProvider = (providerId) => {
+		throw new Error("LlmProviderManager.requireProvider is not implemented.");
+	};
+	saveProvider = (provider) => {
+		throw new Error("LlmProviderManager.saveProvider is not implemented.");
+	};
+	enableProvider = (providerId) => {
+		throw new Error("LlmProviderManager.enableProvider is not implemented.");
+	};
+	disableProvider = (providerId) => {
+		throw new Error("LlmProviderManager.disableProvider is not implemented.");
+	};
+	selectProvider = (input) => {
+		throw new Error("LlmProviderManager.selectProvider is not implemented.");
+	};
+};
+//#endregion
+//#region src/managers/session.manager.ts
+var SessionManager = class {
+	listSessions = () => {
+		throw new Error("SessionManager.listSessions is not implemented.");
+	};
+	getSession = (sessionId) => {
+		throw new Error("SessionManager.getSession is not implemented.");
+	};
+	requireSession = (sessionId) => {
+		throw new Error("SessionManager.requireSession is not implemented.");
+	};
+	createSession = (input) => {
+		throw new Error("SessionManager.createSession is not implemented.");
+	};
+	saveSession = (session) => {
+		throw new Error("SessionManager.saveSession is not implemented.");
+	};
+	appendMessage = (sessionId, message) => {
+		throw new Error("SessionManager.appendMessage is not implemented.");
+	};
+	attachTask = (sessionId, taskId) => {
+		throw new Error("SessionManager.attachTask is not implemented.");
+	};
+	closeSession = (sessionId) => {
+		throw new Error("SessionManager.closeSession is not implemented.");
+	};
+};
+//#endregion
+//#region src/managers/skill.manager.ts
+var SkillManager = class {
+	listSkills = () => {
+		throw new Error("SkillManager.listSkills is not implemented.");
+	};
+	getSkill = (skillId) => {
+		throw new Error("SkillManager.getSkill is not implemented.");
+	};
+	requireSkill = (skillId) => {
+		throw new Error("SkillManager.requireSkill is not implemented.");
+	};
+	saveSkill = (skill) => {
+		throw new Error("SkillManager.saveSkill is not implemented.");
+	};
+	enableSkill = (skillId) => {
+		throw new Error("SkillManager.enableSkill is not implemented.");
+	};
+	disableSkill = (skillId) => {
+		throw new Error("SkillManager.disableSkill is not implemented.");
+	};
+	resolveSkills = (skillIds) => {
+		throw new Error("SkillManager.resolveSkills is not implemented.");
+	};
+};
+//#endregion
+//#region src/managers/task.manager.ts
+var TaskManager = class {
+	listTasks = () => {
+		throw new Error("TaskManager.listTasks is not implemented.");
+	};
+	getTask = (taskId) => {
+		throw new Error("TaskManager.getTask is not implemented.");
+	};
+	requireTask = (taskId) => {
+		throw new Error("TaskManager.requireTask is not implemented.");
+	};
+	createTask = (input) => {
+		throw new Error("TaskManager.createTask is not implemented.");
+	};
+	saveTask = (task) => {
+		throw new Error("TaskManager.saveTask is not implemented.");
+	};
+	updateTaskStatus = (taskId, status) => {
+		throw new Error("TaskManager.updateTaskStatus is not implemented.");
+	};
+	completeTask = (taskId, output) => {
+		throw new Error("TaskManager.completeTask is not implemented.");
+	};
+	failTask = (taskId, error) => {
+		throw new Error("TaskManager.failTask is not implemented.");
+	};
+	cancelTask = (taskId) => {
+		throw new Error("TaskManager.cancelTask is not implemented.");
+	};
+};
+//#endregion
+//#region src/managers/tool.manager.ts
+var ToolManager = class {
+	listTools = () => {
+		throw new Error("ToolManager.listTools is not implemented.");
+	};
+	getTool = (toolId) => {
+		throw new Error("ToolManager.getTool is not implemented.");
+	};
+	requireTool = (toolId) => {
+		throw new Error("ToolManager.requireTool is not implemented.");
+	};
+	saveTool = (tool) => {
+		throw new Error("ToolManager.saveTool is not implemented.");
+	};
+	enableTool = (toolId) => {
+		throw new Error("ToolManager.enableTool is not implemented.");
+	};
+	disableTool = (toolId) => {
+		throw new Error("ToolManager.disableTool is not implemented.");
+	};
+	resolveTools = (toolIds) => {
+		throw new Error("ToolManager.resolveTools is not implemented.");
+	};
+};
+//#endregion
+//#region src/app/nextclaw-kernel.ts
+var NextclawKernelControlManager = class {
+	runtimeControl = null;
+	installRuntimeControl = (runtimeControl) => {
+		this.runtimeControl = runtimeControl;
+	};
+	requireRuntimeControl = () => {
+		if (!this.runtimeControl) throw new Error("Kernel runtime control is not installed.");
+		return this.runtimeControl;
+	};
+};
+var NextclawKernel = class {
+	agents = new AgentManager();
+	tasks = new TaskManager();
+	sessions = new SessionManager();
+	contextBuilder = new ContextBuilder(this.sessions);
+	control = new NextclawKernelControlManager();
+	tools = new ToolManager();
+	skills = new SkillManager();
+	llmProviders = new LlmProviderManager();
+	automation = new AutomationManager();
+	channels = new ChannelManager();
+	run = (input) => {
+		throw new Error("NextclawKernel.run is not implemented.");
+	};
+};
+//#endregion
+export { AgentManager, AutomationManager, ChannelManager, ContextBuilder, LlmProviderManager, NextclawKernel, SessionManager, SkillManager, TaskManager, ToolManager };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@nextclaw/kernel",
+  "version": "0.1.1",
+  "private": false,
+  "description": "NextClaw product kernel skeleton for agents, tasks, sessions, context, tools, skills, providers, automation, and channels.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nextclaw/ncp": "0.5.5"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.6",
+    "prettier": "^3.3.3",
+    "typescript": "^5.6.3"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --dts --clean --target es2022 --no-fixedExtension",
+    "lint": "eslint .",
+    "tsc": "tsc -p tsconfig.json"
+  }
+}