openclaw-contextualai 1.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI - Type Check, Format & Lint
+
+on:
+  pull_request:
+
+jobs:
+  quality-checks:
+    name: Quality Checks
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Setup Biome
+        uses: biomejs/setup-biome@v2
+        with:
+          version: 2.3.8
+
+      - name: Run TypeScript type checking
+        run: npm run check-types
+
+      - name: Run Biome CI (format & lint)
+        run: npx biome ci .

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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/README.md

@@ -0,0 +1,65 @@
+# Contextual AI Plugin for OpenClaw
+
+Connect OpenClaw to [Contextual AI](https://contextual.ai) agents: list your agents and let the LLM route user questions to the right agent.
+
+## Install
+
+```bash
+openclaw plugins install openclaw-contextualai
+```
+
+Restart OpenClaw after installing.
+
+## Configuration
+
+The only required value is your Contextual AI API key. Get one at [app.contextual.ai](https://app.contextual.ai) (API Keys in the dashboard).
+
+**Option A – Environment variable:**
+
+```bash
+export OPENCLAW_CONTEXTUALAI_API_KEY="your-contextual-ai-api-key"
+```
+
+**Option B – In `openclaw.json`:**
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "openclaw-contextualai": {
+        "enabled": true,
+        "config": {
+          "apiKey": "your-contextual-ai-api-key"
+        }
+      }
+    }
+  }
+}
+```
+
+## How to use
+
+In any channel where OpenClaw is running:
+
+- **List your agents** – e.g. *“What Contextual AI agents do I have?”* or *“List my Contextual AI agents.”*
+- **Query an agent** – e.g. *“Ask the Materials Science Agent: What materials are best for high-temperature aerospace?”*
+
+The model will list your agents, then send your question to the right one and reply with the agent’s answer.
+
+## AI Tools
+
+The AI can use these tools during conversations:
+
+| Tool | Description |
+|------|-------------|
+| `contextualai_list_agents` | List available Contextual AI agents (id, name, description). |
+| `contextualai_query_agent` | Send a message to a specific agent by id and return its response. |
+
+## Optional config
+
+| Key       | Type    | Default                     | Description                                 |
+|----------|---------|-----------------------------|---------------------------------------------|
+| `baseUrl`| string  | `https://api.contextual.ai` | API base URL.                               |
+| `debug`  | boolean | false                       | Log request URL and response status.        |
+
+Env vars: `OPENCLAW_CONTEXTUALAI_BASE_URL`, `OPENCLAW_CONTEXTUALAI_API_KEY` (or set `apiKey` in config).

package/biome.json

@@ -0,0 +1,77 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.3.8/schema.json",
+	"assist": {
+		"actions": {
+			"source": {
+				"organizeImports": "on",
+				"useSortedAttributes": "on",
+				"useSortedKeys": "off"
+			}
+		},
+		"enabled": true
+	},
+	"files": {
+		"includes": [
+			"**",
+			"!**/node_modules",
+			"!**/dist",
+			"!**/bun.lock",
+			"!**/*.lock"
+		]
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double",
+			"semicolons": "asNeeded"
+		}
+	},
+	"linter": {
+		"domains": {
+			"project": "none"
+		},
+		"enabled": true,
+		"rules": {
+			"correctness": {
+				"useYield": "warn",
+				"noUnusedVariables": {
+					"level": "warn",
+					"options": {
+						"ignoreRestSiblings": true
+					}
+				},
+				"noUnusedImports": "warn",
+				"useParseIntRadix": "off"
+			},
+			"recommended": true,
+			"style": {
+				"noDefaultExport": "off",
+				"noInferrableTypes": "error",
+				"noNonNullAssertion": "warn",
+				"noParameterAssign": "error",
+				"noUnusedTemplateLiteral": "error",
+				"noUselessElse": "error",
+				"useAsConstAssertion": "error",
+				"useDefaultParameterLast": "error",
+				"useEnumInitializers": "error",
+				"useNamingConvention": {
+					"level": "off",
+					"options": {
+						"strictCase": false
+					}
+				},
+				"useNumberNamespace": "error",
+				"useSelfClosingElements": "error",
+				"useSingleVarDeclarator": "error"
+			}
+		}
+	},
+	"vcs": {
+		"clientKind": "git",
+		"enabled": true,
+		"useIgnoreFile": true
+	}
+}

package/client.ts

@@ -0,0 +1,137 @@
+import type { ContextualAiConfig } from "./config.ts"
+
+export type AgentEntry = {
+	id: string
+	name: string
+	description: string
+}
+
+export type ListAgentsResult = {
+	agents: AgentEntry[]
+	next_cursor?: string
+}
+
+export type MessageRole = {
+	role: "user" | "assistant"
+	content: string
+}
+
+export type QueryAgentResult = {
+	content: string
+	conversation_id?: string
+	message_id?: string
+}
+
+function normalizeBaseUrl(baseUrl: string): string {
+	const trimmed = baseUrl.replace(/\/+$/, "")
+	if (trimmed.endsWith("/v1")) return trimmed
+	return `${trimmed}/v1`
+}
+
+const API_KEY_REQUIRED_MSG =
+	"openclaw-contextualai: apiKey is required (set in plugin config or OPENCLAW_CONTEXTUALAI_API_KEY env var)"
+
+export class ContextualAiClient {
+	private apiKey: string
+	private baseUrl: string
+	private debug: boolean
+
+	constructor(cfg: Pick<ContextualAiConfig, "apiKey" | "baseUrl" | "debug">) {
+		this.apiKey = cfg.apiKey ?? ""
+		this.baseUrl = normalizeBaseUrl(cfg.baseUrl)
+		this.debug = cfg.debug ?? false
+	}
+
+	private ensureApiKey(): void {
+		if (!this.apiKey || this.apiKey.length === 0) {
+			throw new Error(API_KEY_REQUIRED_MSG)
+		}
+	}
+
+	private async request<T>(
+		method: string,
+		path: string,
+		body?: unknown,
+	): Promise<T> {
+		const url = `${this.baseUrl}${path}`
+		if (this.debug) {
+			// eslint-disable-next-line no-console
+			console.debug(`[contextualai] ${method} ${url}`)
+		}
+
+		const headers: Record<string, string> = {
+			Authorization: `Bearer ${this.apiKey}`,
+		}
+		if (body !== undefined) {
+			headers["Content-Type"] = "application/json"
+		}
+
+		const res = await fetch(url, {
+			method,
+			headers,
+			body: body !== undefined ? JSON.stringify(body) : undefined,
+		})
+
+		if (this.debug) {
+			// eslint-disable-next-line no-console
+			console.debug(`[contextualai] ${res.status} ${path}`)
+		}
+
+		const text = await res.text()
+		if (!res.ok) {
+			throw new Error(
+				`Contextual AI API error ${res.status}: ${text || res.statusText}`,
+			)
+		}
+
+		if (text.length === 0) {
+			return undefined as T
+		}
+		try {
+			return JSON.parse(text) as T
+		} catch {
+			throw new Error(`Contextual AI API invalid JSON: ${text.slice(0, 200)}`)
+		}
+	}
+
+	async listAgents(limit = 100, cursor?: string): Promise<ListAgentsResult> {
+		this.ensureApiKey()
+		const params = new URLSearchParams()
+		params.set("limit", String(limit))
+		if (cursor) params.set("cursor", cursor)
+		const path = `/agents?${params.toString()}`
+		const data = await this.request<{ next_cursor?: string; agents?: AgentEntry[] }>(
+			"GET",
+			path,
+		)
+		return {
+			agents: data.agents ?? [],
+			next_cursor: data.next_cursor,
+		}
+	}
+
+	async queryAgent(
+		agentId: string,
+		messages: MessageRole[],
+		conversationId?: string,
+	): Promise<QueryAgentResult> {
+		this.ensureApiKey()
+		const body: { messages: MessageRole[]; conversation_id?: string } = {
+			messages,
+		}
+		if (conversationId) body.conversation_id = conversationId
+
+		const path = `/agents/${encodeURIComponent(agentId)}/query`
+		const data = await this.request<{
+			conversation_id?: string
+			message_id?: string
+			message?: { content?: string; role?: string }
+		}>("POST", path, body)
+
+		return {
+			content: data.message?.content ?? "",
+			conversation_id: data.conversation_id,
+			message_id: data.message_id,
+		}
+	}
+}

package/commands/slash.ts

@@ -0,0 +1,37 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
+import type { ContextualAiConfig } from "../config.ts"
+
+export function registerCommands(
+	api: OpenClawPluginApi,
+	_cfg: ContextualAiConfig,
+): void {
+	api.registerCommand({
+		name: "contextai",
+		description: "Inspect or test Contextual AI configuration and behavior.",
+		acceptsArgs: true,
+		requireAuth: true,
+		async handler(ctx: { args?: string }) {
+			const subcommand = ctx.args?.trim() || "help"
+
+			if (subcommand === "help") {
+				return {
+					text:
+						"/contextai commands:\n" +
+						"- /contextai help    Show this help.\n" +
+						"- /contextai ping    Check that the plugin is wired correctly.\n",
+				}
+			}
+
+			if (subcommand === "ping") {
+				return {
+					text: "openclaw-contextualai: plugin is installed and responding.",
+				}
+			}
+
+			return {
+				text: `Unknown subcommand: "${subcommand}". Try /contextai help.`,
+			}
+		},
+	})
+}
+

package/config.ts

@@ -0,0 +1,78 @@
+export type ContextualAiConfig = {
+	apiKey: string
+	baseUrl: string
+	projectId?: string
+	autoInject: boolean
+	maxContextTokens: number
+	debug: boolean
+}
+
+const ALLOWED_KEYS = [
+	"apiKey",
+	"baseUrl",
+	"projectId",
+	"autoInject",
+	"maxContextTokens",
+	"debug",
+] as const
+
+function assertAllowedKeys(
+	value: Record<string, unknown>,
+	allowed: readonly string[],
+	label: string,
+): void {
+	const unknown = Object.keys(value).filter((k) => !allowed.includes(k))
+	if (unknown.length > 0) {
+		throw new Error(`${label} has unknown keys: ${unknown.join(", ")}`)
+	}
+}
+
+function resolveEnvVars(value: string): string {
+	return value.replace(/\$\{([^}]+)\}/g, (_, envVar: string) => {
+		const envValue = process.env[envVar]
+		if (!envValue) {
+			throw new Error(`Environment variable ${envVar} is not set`)
+		}
+		return envValue
+	})
+}
+
+export function parseConfig(raw: unknown): ContextualAiConfig {
+	const cfg =
+		raw && typeof raw === "object" && !Array.isArray(raw)
+			? (raw as Record<string, unknown>)
+			: {}
+
+	if (Object.keys(cfg).length > 0) {
+		assertAllowedKeys(cfg, ALLOWED_KEYS, "openclaw-contextualai config")
+	}
+
+	const apiKeyValue = cfg.apiKey ?? process.env.OPENCLAW_CONTEXTUALAI_API_KEY
+	const baseUrlValue =
+		cfg.baseUrl ?? process.env.OPENCLAW_CONTEXTUALAI_BASE_URL ?? "https://api.contextual.ai"
+
+	// Allow missing key at startup so the gateway can start; the client will throw when a tool is used.
+	const apiKey =
+		apiKeyValue && typeof apiKeyValue === "string" && apiKeyValue.length > 0
+			? resolveEnvVars(apiKeyValue)
+			: ""
+
+	const baseUrl =
+		typeof baseUrlValue === "string" && baseUrlValue.length > 0
+			? resolveEnvVars(baseUrlValue)
+			: "https://api.contextual.ai"
+
+	return {
+		apiKey,
+		baseUrl,
+		projectId: typeof cfg.projectId === "string" ? cfg.projectId : undefined,
+		autoInject: (cfg.autoInject as boolean) ?? true,
+		maxContextTokens: (cfg.maxContextTokens as number) ?? 4096,
+		debug: (cfg.debug as boolean) ?? false,
+	}
+}
+
+export const contextualAiConfigSchema = {
+	parse: parseConfig,
+}
+

package/hooks/before_agent_start.ts

@@ -0,0 +1,23 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
+import type { ContextualAiConfig } from "../config.ts"
+
+export function registerBeforeAgentStartHook(
+	api: OpenClawPluginApi,
+	_cfg: ContextualAiConfig,
+): void {
+	api.on(
+		"before_agent_start",
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		async (event: Record<string, any>, _ctx: Record<string, any>) => {
+			// TODO: use your contextual backend + event/ctx to fetch relevant context.
+			// For now, we just return the original event without modifications.
+
+			// Example of how you might eventually inject context:
+			// const extraContext = await fetchContextFromBackend(event, ctx, cfg)
+			// return { ...event, prependContext: extraContext }
+
+			return event
+		},
+	)
+}
+

package/index.ts

@@ -0,0 +1,43 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
+import { ContextualAiClient } from "./client.ts"
+import { parseConfig, contextualAiConfigSchema } from "./config.ts"
+import { registerBeforeAgentStartHook } from "./hooks/before_agent_start.ts"
+import { registerCommands } from "./commands/slash.ts"
+import { registerListAgentsTool } from "./tools/contextualai_list_agents.ts"
+import { registerQueryAgentTool } from "./tools/contextualai_query_agent.ts"
+import { registerContextualLookupTool } from "./tools/contextualai_lookup.ts"
+
+export default {
+	id: "openclaw-contextualai",
+	name: "Contextual AI",
+	description: "Context-aware extension for OpenClaw that injects relevant context into conversations.",
+	kind: "extension" as const,
+	configSchema: contextualAiConfigSchema,
+
+	register(api: OpenClawPluginApi) {
+		const cfg = parseConfig(api.pluginConfig)
+		const client = new ContextualAiClient(cfg)
+
+		// Register tools: list agents and query agent (Step 1 – talk to Contextual AI agents directly).
+		registerListAgentsTool(api, client, cfg)
+		registerQueryAgentTool(api, client, cfg)
+		registerContextualLookupTool(api, cfg)
+
+		// Register hooks to inject context before agent runs.
+		registerBeforeAgentStartHook(api, cfg)
+
+		// Register basic slash commands for debugging / inspection.
+		registerCommands(api, cfg)
+
+		api.registerService({
+			id: "openclaw-contextualai",
+			start: () => {
+				api.logger.info("openclaw-contextualai: connected")
+			},
+			stop: () => {
+				api.logger.info("openclaw-contextualai: stopped")
+			},
+		})
+	},
+}
+

package/openclaw.plugin.json

@@ -0,0 +1,53 @@
+{
+	"id": "openclaw-contextualai",
+	"kind": "extension",
+	"uiHints": {
+		"apiKey": {
+			"label": "Contextual AI API Key",
+			"sensitive": true,
+			"placeholder": "${OPENCLAW_CONTEXTUALAI_API_KEY}",
+			"help": "API key for your Contextual AI backend. You can also set it via the OPENCLAW_CONTEXTUALAI_API_KEY environment variable."
+		},
+		"baseUrl": {
+			"label": "Base URL",
+			"placeholder": "https://api.contextual.ai",
+			"help": "Base URL for the Contextual AI service.",
+			"advanced": true
+		},
+		"projectId": {
+			"label": "Project ID",
+			"placeholder": "optional-project-id",
+			"help": "Optional project or workspace identifier used by your contextual backend.",
+			"advanced": true
+		},
+		"autoInject": {
+			"label": "Auto Inject Context",
+			"help": "Automatically fetch and inject relevant contextual information before every AI turn."
+		},
+		"maxContextTokens": {
+			"label": "Max Context Tokens",
+			"placeholder": "4096",
+			"help": "Maximum number of tokens of contextual information to inject into each turn.",
+			"advanced": true
+		},
+		"debug": {
+			"label": "Debug Logging",
+			"help": "Enable verbose debug logs for contextual requests and responses.",
+			"advanced": true
+		}
+	},
+	"configSchema": {
+		"type": "object",
+		"additionalProperties": false,
+		"properties": {
+			"apiKey": { "type": "string" },
+			"baseUrl": { "type": "string" },
+			"projectId": { "type": "string" },
+			"autoInject": { "type": "boolean" },
+			"maxContextTokens": { "type": "number", "minimum": 512, "maximum": 32768 },
+			"debug": { "type": "boolean" }
+		},
+		"required": []
+	}
+}
+

package/package.json

@@ -0,0 +1,24 @@
+{
+	"name": "openclaw-contextualai",
+	"version": "1.0.0",
+	"type": "module",
+	"description": "Contextual AI extension for OpenClaw",
+	"license": "MIT",
+	"scripts": {
+		"check-types": "tsc --noEmit",
+		"lint": "bunx @biomejs/biome ci .",
+		"lint:fix": "bunx @biomejs/biome check --write ."
+	},
+	"peerDependencies": {
+		"openclaw": ">=2026.1.29"
+	},
+	"openclaw": {
+		"extensions": [
+			"./index.ts"
+		]
+	},
+	"devDependencies": {
+		"@sinclair/typebox": "0.34.47",
+		"typescript": "^5.9.3"
+	}
+}

package/tools/contextualai_list_agents.ts

@@ -0,0 +1,62 @@
+import { Type } from "@sinclair/typebox"
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
+import type { ContextualAiClient } from "../client.ts"
+import type { ContextualAiConfig } from "../config.ts"
+
+export function registerListAgentsTool(
+	api: OpenClawPluginApi,
+	client: ContextualAiClient,
+	_cfg: ContextualAiConfig,
+): void {
+	api.registerTool(
+		{
+			name: "contextualai_list_agents",
+			label: "List Contextual AI Agents",
+			description:
+				"Returns the list of Contextual AI agents available to query. Use this to see agent id, name, and description so you can choose the right agent and call contextualai_query_agent with its id.",
+			parameters: Type.Object({
+				limit: Type.Optional(
+					Type.Number({
+						description: "Maximum number of agents to return (default 50)",
+						default: 50,
+					}),
+				),
+			}),
+			async execute(_toolCallId: string, params: { limit?: number }) {
+				const limit = params.limit ?? 50
+				const result = await client.listAgents(limit)
+
+				if (result.agents.length === 0) {
+					return {
+						content: [
+							{
+								type: "text" as const,
+								text: "No Contextual AI agents found.",
+							},
+						],
+						details: { agents: [], count: 0 },
+					}
+				}
+
+				const lines = result.agents.map(
+					(a) => `- **${a.name}** (id: \`${a.id}\`): ${a.description ?? ""}`,
+				)
+				const text =
+					`Found ${result.agents.length} agent(s):\n\n${lines.join("\n")}` +
+					(result.next_cursor
+						? "\n\n(More agents available; use limit to fetch more.)"
+						: "")
+
+				return {
+					content: [{ type: "text" as const, text }],
+					details: {
+						agents: result.agents,
+						count: result.agents.length,
+						next_cursor: result.next_cursor,
+					},
+				}
+			},
+		},
+		{ name: "contextualai_list_agents" },
+	)
+}

package/tools/contextualai_lookup.ts

@@ -0,0 +1,44 @@
+import { Type } from "@sinclair/typebox"
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
+import type { ContextualAiConfig } from "../config.ts"
+
+export function registerContextualLookupTool(
+	api: OpenClawPluginApi,
+	_cfg: ContextualAiConfig,
+): void {
+	api.registerTool(
+		{
+			name: "contextualai_lookup",
+			label: "Contextual Lookup",
+			description:
+				"Fetches contextual information relevant to the current conversation or query.",
+			parameters: Type.Object({
+				query: Type.String({
+					description:
+						"Natural language description of the context the AI wants to retrieve.",
+				}),
+			}),
+			// Note: this is a stub implementation – wire it to your backend later.
+			async execute(_toolCallId: string, params: { query: string }) {
+				const preview =
+					params.query.length > 120
+						? `${params.query.slice(0, 120)}…`
+						: params.query
+
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text:
+								`[contextualai_lookup] This is a placeholder response for query: "${preview}". ` +
+								"Wire this tool up to your contextual backend to return real context snippets.",
+						},
+					],
+					details: {},
+				}
+			},
+		},
+		{ name: "contextualai_lookup" },
+	)
+}
+

package/tools/contextualai_query_agent.ts

@@ -0,0 +1,81 @@
+import { Type } from "@sinclair/typebox"
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
+import type { ContextualAiClient } from "../client.ts"
+import type { ContextualAiConfig } from "../config.ts"
+
+export function registerQueryAgentTool(
+	api: OpenClawPluginApi,
+	client: ContextualAiClient,
+	_cfg: ContextualAiConfig,
+): void {
+	api.registerTool(
+		{
+			name: "contextualai_query_agent",
+			label: "Query Contextual AI Agent",
+			description:
+				"Send a message to a specific Contextual AI agent by its id (from contextualai_list_agents) and get the agent's response. Use this to redirect user questions to the appropriate specialist agent.",
+			parameters: Type.Object({
+				agent_id: Type.String({
+					description: "UUID of the agent to query (from contextualai_list_agents)",
+				}),
+				message: Type.String({
+					description: "The user message or question to send to the agent",
+				}),
+				conversation_id: Type.Optional(
+					Type.String({
+						description:
+							"Optional conversation id for follow-up messages in the same thread",
+					}),
+				),
+			}),
+			async execute(
+				_toolCallId: string,
+				params: { agent_id: string; message: string; conversation_id?: string },
+			) {
+				try {
+					const result = await client.queryAgent(
+						params.agent_id,
+						[{ role: "user", content: params.message }],
+						params.conversation_id,
+					)
+
+					if (!result.content) {
+						return {
+							content: [
+								{
+									type: "text" as const,
+									text: "The agent returned an empty response.",
+								},
+							],
+							details: {
+								conversation_id: result.conversation_id,
+								message_id: result.message_id,
+							},
+						}
+					}
+
+					return {
+						content: [{ type: "text" as const, text: result.content }],
+						details: {
+							conversation_id: result.conversation_id,
+							message_id: result.message_id,
+						},
+					}
+				} catch (err) {
+					const message =
+						err instanceof Error ? err.message : String(err)
+					return {
+						content: [
+							{
+								type: "text" as const,
+								text: `Contextual AI query failed: ${message}`,
+							},
+						],
+						details: {},
+					}
+				}
+			},
+		},
+		{ name: "contextualai_query_agent" },
+	)
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ES2022",
+		"moduleResolution": "bundler",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"allowImportingTsExtensions": true,
+		"noEmit": true,
+		"rootDir": "."
+	},
+	"include": [
+		"*.ts",
+		"tools/*.ts",
+		"hooks/*.ts",
+		"commands/*.ts",
+		"types/*.d.ts"
+	],
+	"exclude": ["node_modules", "dist"]
+}