@clinebot/core 0.0.0

package/src/chat/chat-schema.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+
+export const ChatSessionConfigSchema = z.object({
+	workspaceRoot: z.string().min(1),
+	cwd: z.string().optional(),
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	mode: z.enum(["act", "plan"]).default("act"),
+	apiKey: z.string(),
+	systemPrompt: z.string().optional(),
+	rules: z.string().optional(),
+	maxIterations: z.number().int().positive().optional(),
+	enableTools: z.boolean(),
+	enableSpawn: z.boolean(),
+	enableTeams: z.boolean(),
+	autoApproveTools: z.boolean().optional(),
+	teamName: z.string().min(1),
+	missionStepInterval: z.number().int().positive(),
+	missionTimeIntervalMs: z.number().int().positive(),
+});
+
+export const ChatSessionStatusSchema = z.enum([
+	"idle",
+	"starting",
+	"running",
+	"stopping",
+	"completed",
+	"cancelled",
+	"failed",
+	"error",
+]);
+
+export const ChatMessageRoleSchema = z.enum([
+	"user",
+	"assistant",
+	"tool",
+	"system",
+	"status",
+	"error",
+]);
+
+export const ChatMessageSchema = z.object({
+	id: z.string().min(1),
+	sessionId: z.string().nullable(),
+	role: ChatMessageRoleSchema,
+	content: z.string(),
+	createdAt: z.number().int().nonnegative(),
+	meta: z
+		.object({
+			stream: z.enum(["stdout", "stderr"]).optional(),
+			toolName: z.string().optional(),
+			iteration: z.number().int().nonnegative().optional(),
+			agentId: z.string().optional(),
+			conversationId: z.string().optional(),
+			hookEventName: z.string().optional(),
+			inputTokens: z.number().int().nonnegative().optional(),
+			outputTokens: z.number().int().nonnegative().optional(),
+		})
+		.optional(),
+});
+
+export const ChatSummarySchema = z.object({
+	toolCalls: z.number().int().nonnegative(),
+	tokensIn: z.number().int().nonnegative(),
+	tokensOut: z.number().int().nonnegative(),
+});
+
+export const ChatViewStateSchema = z.object({
+	sessionId: z.string().nullable(),
+	status: ChatSessionStatusSchema,
+	config: ChatSessionConfigSchema,
+	messages: z.array(ChatMessageSchema),
+	rawTranscript: z.string(),
+	error: z.string().nullable(),
+	summary: ChatSummarySchema,
+});
+
+export type ChatSessionConfig = z.infer<typeof ChatSessionConfigSchema>;
+export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ChatSummary = z.infer<typeof ChatSummarySchema>;
+export type ChatViewState = z.infer<typeof ChatViewStateSchema>;

package/src/default-tools/constants.ts

@@ -0,0 +1,35 @@
+/**
+ * Constants for Default Tools
+ *
+ * Tool name constants and utility arrays.
+ */
+
+import type { DefaultToolName } from "./types.js";
+
+/**
+ * Constants for default tool names
+ */
+export const DefaultToolNames = {
+	READ_FILES: "read_files",
+	SEARCH_CODEBASE: "search_codebase",
+	RUN_COMMANDS: "run_commands",
+	FETCH_WEB_CONTENT: "fetch_web_content",
+	APPLY_PATCH: "apply_patch",
+	EDITOR: "editor",
+	SKILLS: "skills",
+	ASK: "ask_question",
+} as const;
+
+/**
+ * Array of all default tool names
+ */
+export const ALL_DEFAULT_TOOL_NAMES: DefaultToolName[] = [
+	DefaultToolNames.READ_FILES,
+	DefaultToolNames.SEARCH_CODEBASE,
+	DefaultToolNames.RUN_COMMANDS,
+	DefaultToolNames.FETCH_WEB_CONTENT,
+	DefaultToolNames.APPLY_PATCH,
+	DefaultToolNames.EDITOR,
+	DefaultToolNames.SKILLS,
+	DefaultToolNames.ASK,
+];

package/src/default-tools/definitions.test.ts

@@ -0,0 +1,233 @@
+import { describe, expect, it, vi } from "vitest";
+import { createDefaultTools, createReadFilesTool } from "./definitions.js";
+
+describe("default skills tool", () => {
+	it("is included only when enabled with a skills executor", () => {
+		const toolsWithoutExecutor = createDefaultTools({
+			executors: {},
+			enableSkills: true,
+		});
+		expect(toolsWithoutExecutor.map((tool) => tool.name)).not.toContain(
+			"skills",
+		);
+
+		const toolsWithExecutor = createDefaultTools({
+			executors: {
+				skills: async () => "ok",
+			},
+			enableSkills: true,
+		});
+		expect(toolsWithExecutor.map((tool) => tool.name)).toContain("skills");
+	});
+
+	it("validates and executes skill invocation input", async () => {
+		const execute = vi.fn(async () => "loaded");
+		const tools = createDefaultTools({
+			executors: {
+				skills: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableSkills: true,
+		});
+		const skillsTool = tools.find((tool) => tool.name === "skills");
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected skills tool to be defined.");
+		}
+
+		const result = await skillsTool.execute(
+			{ skill: "commit", args: "-m 'fix'" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toBe("loaded");
+		expect(execute).toHaveBeenCalledWith(
+			"commit",
+			"-m 'fix'",
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+});
+
+describe("default ask_question tool", () => {
+	it("is enabled by default when executor is provided", () => {
+		const tools = createDefaultTools({
+			executors: {
+				askQuestion: async () => "ok",
+			},
+		});
+		expect(tools.map((tool) => tool.name)).toContain("ask_question");
+	});
+
+	it("is excluded when explicitly disabled", () => {
+		const tools = createDefaultTools({
+			executors: {
+				askQuestion: async () => "ok",
+			},
+			enableAskQuestion: false,
+		});
+		expect(tools.map((tool) => tool.name)).not.toContain("ask_question");
+	});
+
+	it("is included only when enabled with an askQuestion executor", () => {
+		const toolsWithoutExecutor = createDefaultTools({
+			executors: {},
+			enableAskQuestion: true,
+		});
+		expect(toolsWithoutExecutor.map((tool) => tool.name)).not.toContain(
+			"ask_question",
+		);
+
+		const toolsWithExecutor = createDefaultTools({
+			executors: {
+				askQuestion: async () => "ok",
+			},
+			enableAskQuestion: true,
+		});
+		expect(toolsWithExecutor.map((tool) => tool.name)).toContain(
+			"ask_question",
+		);
+	});
+
+	it("validates and executes ask_question input", async () => {
+		const execute = vi.fn(async () => "asked");
+		const tools = createDefaultTools({
+			executors: {
+				askQuestion: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableSkills: false,
+			enableAskQuestion: true,
+		});
+		const askTool = tools.find((tool) => tool.name === "ask_question");
+		expect(askTool).toBeDefined();
+		if (!askTool) {
+			throw new Error("Expected ask_question tool to be defined.");
+		}
+
+		const result = await askTool.execute(
+			{
+				question: "Which approach should I take?",
+				options: ["Option 1", "Option 2"],
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toBe("asked");
+		expect(execute).toHaveBeenCalledWith(
+			"Which approach should I take?",
+			["Option 1", "Option 2"],
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+});
+
+describe("default apply_patch tool", () => {
+	it("is included only when enabled with an applyPatch executor", () => {
+		const toolsWithoutExecutor = createDefaultTools({
+			executors: {},
+			enableApplyPatch: true,
+		});
+		expect(toolsWithoutExecutor.map((tool) => tool.name)).not.toContain(
+			"apply_patch",
+		);
+
+		const toolsWithExecutor = createDefaultTools({
+			executors: {
+				applyPatch: async () => "ok",
+			},
+			enableApplyPatch: true,
+		});
+		expect(toolsWithExecutor.map((tool) => tool.name)).toContain("apply_patch");
+	});
+
+	it("validates and executes apply_patch input", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				applyPatch: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: true,
+		});
+
+		const applyPatchTool = tools.find((tool) => tool.name === "apply_patch");
+		expect(applyPatchTool).toBeDefined();
+		if (!applyPatchTool) {
+			throw new Error("Expected apply_patch tool to be defined.");
+		}
+
+		const result = await applyPatchTool.execute(
+			{ input: "*** Begin Patch\n*** End Patch" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "apply_patch",
+			result: "patched",
+			success: true,
+		});
+		expect(execute).toHaveBeenCalledWith(
+			{ input: "*** Begin Patch\n*** End Patch" },
+			process.cwd(),
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+});
+
+describe("zod schema conversion", () => {
+	it("preserves read_files required properties in generated JSON schema", () => {
+		const tool = createReadFilesTool(async () => "ok");
+		const inputSchema = tool.inputSchema as Record<string, unknown>;
+		const properties = inputSchema.properties as Record<string, unknown>;
+		expect(inputSchema.type).toBe("object");
+		expect(properties.file_paths).toEqual({
+			type: "array",
+			items: {
+				type: "string",
+				description:
+					"The absolute file path of a text file to read content from",
+			},
+			description: "Array of absolute file paths",
+		});
+		expect(inputSchema.required).toEqual(["file_paths"]);
+	});
+});