@doist/todoist-ai 0.1.0 → 0.1.1

package/dist/tools/tasks-search.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tasks-search.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqBxB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYyB,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/tools/tasks-update-one.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tasks-update-one.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-update-one.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqCxB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;CAQsB,CAAC;AAE3C,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/src/index.ts

@@ -1 +0,0 @@
-export { getMcpServer } from "./mcp-server.js";

package/src/main.ts

@@ -1,26 +0,0 @@
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import dotenv from "dotenv";
-import { getMcpServer } from "./mcp-server.js";
-
-function main() {
-	const todoistApiKey = process.env.TODOIST_API_KEY;
-	if (!todoistApiKey) {
-		throw new Error("TODOIST_API_KEY is not set");
-	}
-
-	const server = getMcpServer({ todoistApiKey });
-	const transport = new StdioServerTransport();
-	server
-		.connect(transport)
-		.then(() => {
-			// We use console.error because standard I/O is being used for the MCP server communication.
-			console.error("Server started");
-		})
-		.catch((error) => {
-			console.error("Error starting the Todoist MCP server:", error);
-			process.exit(1);
-		});
-}
-
-dotenv.config();
-main();

package/src/mcp-helpers.ts

@@ -1,76 +0,0 @@
-import type { TodoistApi } from "@doist/todoist-api-typescript";
-import type {
-	McpServer,
-	ToolCallback,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ZodTypeAny, z } from "zod";
-import type { TodoistTool } from "./todoist-tool.js";
-
-function textContent(text: string) {
-	return {
-		content: [{ type: "text" as const, text }],
-	};
-}
-
-function jsonContent(data: unknown) {
-	return {
-		content: [
-			{
-				type: "text" as const,
-				mimeType: "application/json",
-				text: JSON.stringify(data, null, 2),
-			},
-		],
-	};
-}
-
-function textOrJsonContent(data: unknown) {
-	return typeof data === "string" ? textContent(data) : jsonContent(data);
-}
-
-function errorContent(error: string) {
-	return {
-		...textContent(error),
-		isError: true,
-	};
-}
-
-/**
- * Register a Todoist tool in an MCP server.
- * @param tool - The tool to register.
- * @param server - The server to register the tool on.
- * @param client - The Todoist API client to use to execute the tool.
- */
-function registerTool<Params extends z.ZodRawShape>(
-	tool: TodoistTool<Params>,
-	server: McpServer,
-	client: TodoistApi,
-) {
-	// @ts-ignore I give up
-	const cb: ToolCallback<Params> = async (
-		args: z.objectOutputType<Params, ZodTypeAny>,
-		_context,
-	) => {
-		try {
-			const result = await tool.execute(
-				args as z.infer<z.ZodObject<Params>>,
-				client,
-			);
-			return textOrJsonContent(result);
-		} catch (error) {
-			console.error(`Error executing tool ${tool.name}:`, {
-				args,
-				error,
-			});
-			const message =
-				error instanceof Error
-					? error.message
-					: "An unknown error occurred";
-			return errorContent(message);
-		}
-	};
-
-	server.tool(tool.name, tool.description, tool.parameters, cb);
-}
-
-export { registerTool };

package/src/todoist-tool.ts

@@ -1,42 +0,0 @@
-import type { TodoistApi } from "@doist/todoist-api-typescript";
-import type { z } from "zod";
-
-/**
- * A Todoist tool that can be used in an MCP server or other conversational AI interfaces.
- */
-type TodoistTool<Params extends z.ZodRawShape> = {
-	/**
-	 * The name of the tool.
-	 */
-	name: string;
-
-	/**
-	 * The description of the tool. This is important for the LLM to understand what the tool does,
-	 * and how to use it.
-	 */
-	description: string;
-
-	/**
-	 * The schema of the parameters of the tool.
-	 *
-	 * This is used to validate the parameters of the tool, as well as to let the LLM know what the
-	 * parameters are.
-	 */
-	parameters: Params;
-
-	/**
-	 * The function that executes the tool.
-	 *
-	 * This is the main function that will be called when the tool is used.
-	 *
-	 * @param args - The arguments of the tool.
-	 * @param client - The Todoist API client used to make requests to the Todoist API.
-	 * @returns The result of the tool.
-	 */
-	execute: (
-		args: z.infer<z.ZodObject<Params>>,
-		client: TodoistApi,
-	) => Promise<unknown>;
-};
-
-export type { TodoistTool };

package/src/tools/account-overview.ts

@@ -1,130 +0,0 @@
-import type {
-	Project,
-	Section,
-	TodoistApi,
-} from "@doist/todoist-api-typescript";
-import type { TodoistTool } from "../todoist-tool.js";
-
-const ArgsSchema = {};
-
-type ProjectWithChildren = Project & {
-	children: ProjectWithChildren[];
-	childOrder: number;
-};
-
-function buildProjectTree(projects: Project[]): Project[] {
-	// Sort projects by childOrder, then build a tree
-	const byId: Record<string, ProjectWithChildren> = {};
-	for (const p of projects) {
-		byId[p.id] = {
-			...p,
-			children: [],
-			childOrder: (p as { childOrder?: number }).childOrder ?? 0,
-		};
-	}
-	const roots: ProjectWithChildren[] = [];
-	for (const p of projects) {
-		const current = byId[p.id];
-		if (!current) continue;
-		if (p.parentId) {
-			const parent = byId[p.parentId];
-			if (parent) {
-				parent.children.push(current);
-			} else {
-				roots.push(current);
-			}
-		} else {
-			roots.push(current);
-		}
-	}
-	function sortTree(nodes: ProjectWithChildren[]) {
-		nodes.sort((a, b) => a.childOrder - b.childOrder);
-		for (const n of nodes) {
-			sortTree(n.children);
-		}
-	}
-	sortTree(roots);
-	return roots;
-}
-
-async function getSectionsByProject(
-	client: TodoistApi,
-	projectIds: string[],
-): Promise<Record<string, Section[]>> {
-	const result: Record<string, Section[]> = {};
-	await Promise.all(
-		projectIds.map(async (projectId) => {
-			const { results } = await client.getSections({ projectId });
-			result[projectId] = results;
-		}),
-	);
-	return result;
-}
-
-function renderProjectMarkdown(
-	project: ProjectWithChildren,
-	sectionsByProject: Record<string, Section[]>,
-	indent = "",
-): string[] {
-	const lines: string[] = [];
-	lines.push(`${indent}- Project: ${project.name} (id=${project.id})`);
-	const sections = sectionsByProject[project.id] || [];
-	for (const section of sections) {
-		lines.push(`${indent}  - Section: ${section.name} (id=${section.id})`);
-	}
-	for (const child of project.children) {
-		lines.push(
-			...renderProjectMarkdown(child, sectionsByProject, `${indent}  `),
-		);
-	}
-	return lines;
-}
-
-const accountOverview = {
-	name: "account-overview",
-	description:
-		"Get a Markdown overview of all projects (with hierarchy and sections) and the inbox project. Useful in almost any context before engaging with Todoist further.",
-	parameters: ArgsSchema,
-	async execute(_args, client) {
-		const { results: projects } = await client.getProjects({});
-		const inbox = projects.find((p) => p.isInboxProject === true);
-		const nonInbox = projects.filter((p) => p.isInboxProject !== true);
-		const tree = buildProjectTree(nonInbox);
-		const allProjectIds = projects.map((p) => p.id);
-		const sectionsByProject = await getSectionsByProject(
-			client,
-			allProjectIds,
-		);
-
-		const lines: string[] = ["# Personal Projects", ""];
-		if (inbox) {
-			lines.push(`- Inbox Project: ${inbox.name} (id=${inbox.id})`);
-			for (const section of sectionsByProject[inbox.id] || []) {
-				lines.push(`  - Section: ${section.name} (id=${section.id})`);
-			}
-		}
-		if (tree.length) {
-			for (const project of tree as ProjectWithChildren[]) {
-				lines.push(
-					...renderProjectMarkdown(project, sectionsByProject),
-				);
-			}
-		} else {
-			lines.push("_No projects found._");
-		}
-		lines.push("");
-		// Add explanation about nesting if there are nested projects
-		const hasNested = (tree as ProjectWithChildren[]).some(
-			(p) => p.children.length > 0,
-		);
-		if (hasNested) {
-			lines.push(
-				"_Note: Indentation indicates that a project is a sub-project of the one above it. This allows for organizing projects hierarchically, with parent projects containing related sub-projects._",
-				"",
-			);
-		}
-		return lines.join("\n");
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { accountOverview };

package/src/tools/index.ts

@@ -1,26 +0,0 @@
-export { projectsList } from "./projects-list.js";
-export { projectsSearch } from "./projects-search.js";
-export { projectsAddOne } from "./projects-add-one.js";
-export { projectsUpdateOne } from "./projects-update-one.js";
-export { projectsDeleteOne } from "./projects-delete-one.js";
-
-export { sectionsSearch } from "./sections-search.js";
-export { sectionsAddOne } from "./sections-add-one.js";
-export { sectionsUpdateOne } from "./sections-update-one.js";
-export { sectionsDeleteOne } from "./sections-delete-one.js";
-
-export { tasksListByDate } from "./tasks-by-date-range.js";
-export { tasksDeleteOne } from "./tasks-delete-one.js";
-export { tasksCompleteMultiple } from "./tasks-complete-multiple.js";
-export { tasksListForProject } from "./tasks-by-project.js";
-export { tasksListOverdue } from "./tasks-list-overdue.js";
-export { tasksSearch } from "./tasks-search.js";
-export { tasksAddMultiple } from "./tasks-add-multiple.js";
-export { tasksUpdateOne } from "./tasks-update-one.js";
-export { tasksOrganizeMultiple } from "./tasks-organize-multiple.js";
-export { tasksListForSection } from "./tasks-list-for-section.js";
-
-export { subtasksListForParentTask } from "./subtasks-list-for-parent-task.js";
-
-export { accountOverview } from "./account-overview.js";
-export { projectOverview } from "./project-overview.js";

package/src/tools/project-overview.ts

@@ -1,130 +0,0 @@
-import type {
-	Project,
-	Section,
-	TodoistApi,
-} from "@doist/todoist-api-typescript";
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-import { mapTask } from "./shared.js";
-
-const ArgsSchema = {
-	projectId: z
-		.string()
-		.min(1)
-		.describe("The ID of the project to get an overview for."),
-};
-
-type MappedTask = ReturnType<typeof mapTask>;
-
-type TaskTreeNode = MappedTask & { children: TaskTreeNode[] };
-
-function buildTaskTree(tasks: MappedTask[]): TaskTreeNode[] {
-	const byId: Record<string, TaskTreeNode> = {};
-	for (const task of tasks) {
-		byId[task.id] = { ...task, children: [] };
-	}
-	const roots: TaskTreeNode[] = [];
-	for (const task of tasks) {
-		const node = byId[task.id];
-		if (!node) continue;
-		if (!task.parentId) {
-			roots.push(node);
-			continue;
-		}
-		const parent = byId[task.parentId];
-		if (parent) {
-			parent.children.push(node);
-		} else {
-			roots.push(node);
-		}
-	}
-	return roots;
-}
-
-function renderTaskTreeMarkdown(tasks: TaskTreeNode[], indent = ""): string[] {
-	const lines: string[] = [];
-	for (const task of tasks) {
-		const idPart = `id=${task.id}`;
-		const duePart = task.dueDate ? `; due=${task.dueDate}` : "";
-		const contentPart = `; content=${task.content}`;
-		lines.push(`${indent}- ${idPart}${duePart}${contentPart}`);
-		if (task.children.length > 0) {
-			lines.push(...renderTaskTreeMarkdown(task.children, `${indent}  `));
-		}
-	}
-	return lines;
-}
-
-async function getAllTasksForProject(
-	client: TodoistApi,
-	projectId: string,
-): Promise<MappedTask[]> {
-	let allTasks: MappedTask[] = [];
-	let cursor: string | undefined = undefined;
-	do {
-		const { results, nextCursor } = await client.getTasks({
-			projectId,
-			limit: 50,
-			cursor: cursor ?? undefined,
-		});
-		allTasks = allTasks.concat(results.map(mapTask));
-		cursor = nextCursor ?? undefined;
-	} while (cursor);
-	return allTasks;
-}
-
-async function getProjectSections(
-	client: TodoistApi,
-	projectId: string,
-): Promise<Section[]> {
-	const { results } = await client.getSections({ projectId });
-	return results;
-}
-
-const projectOverview = {
-	name: "project-overview",
-	description:
-		"Get a Markdown overview of a single project, including its sections and all tasks. Tasks are grouped by section, with tasks not in any section listed first. Each task is listed as '- id=TASKID; due=YYYY-MM-DD; content=TASK CONTENT' (omit due if not present). Subtasks are nested as indented list items.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		const { projectId } = args;
-		const project: Project = await client.getProject(projectId);
-		const sections = await getProjectSections(client, projectId);
-		const allTasks = await getAllTasksForProject(client, projectId);
-
-		// Group tasks by sectionId
-		const tasksBySection: Record<string, MappedTask[]> = {};
-		for (const section of sections) {
-			tasksBySection[section.id] = [];
-		}
-		const tasksWithoutSection: MappedTask[] = [];
-		for (const task of allTasks) {
-			if (task.sectionId && tasksBySection[task.sectionId]) {
-				// biome-ignore lint/style/noNonNullAssertion: the "if" above ensures that it is defined
-				tasksBySection[task.sectionId]!.push(task);
-			} else {
-				tasksWithoutSection.push(task);
-			}
-		}
-
-		const lines: string[] = [`# ${project.name}`];
-		if (tasksWithoutSection.length > 0) {
-			lines.push("");
-			const tree = buildTaskTree(tasksWithoutSection);
-			lines.push(...renderTaskTreeMarkdown(tree));
-		}
-		for (const section of sections) {
-			lines.push("");
-			lines.push(`## ${section.name}`);
-			const sectionTasks = tasksBySection[section.id];
-			if (!sectionTasks?.length) {
-				continue;
-			}
-			const tree = buildTaskTree(sectionTasks);
-			lines.push(...renderTaskTreeMarkdown(tree));
-		}
-		return lines.join("\n");
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { projectOverview };

package/src/tools/projects-add-one.ts

@@ -1,19 +0,0 @@
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-import { mapProject } from "./shared.js";
-
-const ArgsSchema = {
-	name: z.string().min(1).describe("The name of the project to add."),
-};
-
-const projectsAddOne = {
-	name: "projects-add-one",
-	description: "Add a new project.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		const project = await client.addProject({ name: args.name });
-		return mapProject(project);
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { projectsAddOne };

package/src/tools/projects-delete-one.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-
-const ArgsSchema = {
-	id: z.string().min(1).describe("The ID of the project to delete."),
-};
-
-const projectsDeleteOne = {
-	name: "projects-delete-one",
-	description: "Delete a project by its ID.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		await client.deleteProject(args.id);
-		return { success: true };
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { projectsDeleteOne };

package/src/tools/projects-list.ts

@@ -1,36 +0,0 @@
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-
-const ArgsSchema = {
-	limit: z
-		.number()
-		.int()
-		.min(1)
-		.max(100)
-		.default(50)
-		.describe("The maximum number of projects to return."),
-	cursor: z
-		.string()
-		.optional()
-		.describe(
-			"The cursor to get the next page of projects (cursor is obtained from the previous call to this tool, with the same parameters).",
-		),
-};
-
-const projectsList = {
-	name: "projects-list",
-	description: "List all projects for the user.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		const { results, nextCursor } = await client.getProjects({
-			limit: args.limit,
-			cursor: args.cursor ?? null,
-		});
-		return {
-			projects: results,
-			nextCursor,
-		};
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { projectsList };

package/src/tools/projects-search.ts

@@ -1,49 +0,0 @@
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-import { mapProject } from "./shared.js";
-
-const ArgsSchema = {
-	search: z
-		.string()
-		.optional()
-		.describe(
-			"Search for a project by name (partial and case insensitive match). If omitted, all projects are returned.",
-		),
-	limit: z
-		.number()
-		.int()
-		.min(1)
-		.max(100)
-		.default(50)
-		.describe("The maximum number of projects to return."),
-	cursor: z
-		.string()
-		.optional()
-		.describe(
-			"The cursor to get the next page of projects (cursor is obtained from the previous call to this tool, with the same parameters).",
-		),
-};
-
-const projectsSearch = {
-	name: "projects-search",
-	description: "Search for projects by name or other criteria.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		const { results, nextCursor } = await client.getProjects({
-			limit: args.limit,
-			cursor: args.cursor ?? null,
-		});
-		const searchLower = args.search ? args.search.toLowerCase() : undefined;
-		const filtered = searchLower
-			? results.filter((project) =>
-					project.name.toLowerCase().includes(searchLower),
-				)
-			: results;
-		return {
-			projects: filtered.map(mapProject),
-			nextCursor,
-		};
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { projectsSearch };

package/src/tools/projects-update-one.ts

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-
-const ArgsSchema = {
-	id: z.string().min(1).describe("The ID of the project to update."),
-	name: z.string().min(1).describe("The new name for the project."),
-};
-
-const projectsUpdateOne = {
-	name: "projects-update-one",
-	description: "Update a project's name by its ID.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		const { id, name } = args;
-		const project = await client.updateProject(id, { name });
-		return project;
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { projectsUpdateOne };

package/src/tools/sections-add-one.ts

@@ -1,25 +0,0 @@
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-
-const ArgsSchema = {
-	name: z.string().min(1).describe("The name of the section to add."),
-	projectId: z
-		.string()
-		.min(1)
-		.describe("The ID of the project to add the section to."),
-};
-
-const sectionsAddOne = {
-	name: "sections-add-one",
-	description: "Add a new section to a project.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		const section = await client.addSection({
-			name: args.name,
-			projectId: args.projectId,
-		});
-		return section;
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { sectionsAddOne };

package/src/tools/sections-delete-one.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-
-const ArgsSchema = {
-	id: z.string().min(1).describe("The ID of the section to delete."),
-};
-
-const sectionsDeleteOne = {
-	name: "sections-delete-one",
-	description: "Delete a section by its ID.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		await client.deleteSection(args.id);
-		return { success: true };
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { sectionsDeleteOne };

package/src/tools/sections-search.ts

@@ -1,39 +0,0 @@
-import type { Section } from "@doist/todoist-api-typescript";
-import { z } from "zod";
-import type { TodoistTool } from "../todoist-tool.js";
-
-const ArgsSchema = {
-	projectId: z
-		.string()
-		.min(1)
-		.describe("The ID of the project to search sections in."),
-	search: z
-		.string()
-		.optional()
-		.describe(
-			"Search for a section by name (partial and case insensitive match). If omitted, all sections in the project are returned.",
-		),
-};
-
-const sectionsSearch = {
-	name: "sections-search",
-	description: "Search for sections by name or other criteria in a project.",
-	parameters: ArgsSchema,
-	async execute(args, client) {
-		const { results } = await client.getSections({
-			projectId: args.projectId,
-		});
-		const searchLower = args.search ? args.search.toLowerCase() : undefined;
-		const filtered = searchLower
-			? results.filter((section: Section) =>
-					section.name.toLowerCase().includes(searchLower),
-				)
-			: results;
-		return filtered.map((section: Section) => ({
-			id: section.id,
-			name: section.name,
-		}));
-	},
-} satisfies TodoistTool<typeof ArgsSchema>;
-
-export { sectionsSearch };