@todu/pi-extensions 0.1.0

package/dist/tools/project-integration-tools.js

@@ -0,0 +1,344 @@
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { ToduProjectIntegrationServiceError } from "../services/todu/todu-project-integration-service.js";
+import { ToduProjectServiceError } from "../services/todu/todu-project-service.js";
+const PROJECT_PRIORITY_VALUES = ["low", "medium", "high"];
+const ProjectCheckParams = Type.Object({
+    repositoryPath: Type.Optional(Type.String({ description: "Optional repository path override" })),
+    provider: Type.Optional(Type.String({ description: "Optional explicit repository provider" })),
+    targetRef: Type.Optional(Type.String({ description: "Optional explicit repository target reference, like owner/repo" })),
+});
+const ProjectRegisterParams = Type.Object({
+    projectName: Type.Optional(Type.String({ description: "Optional project name override" })),
+    repositoryPath: Type.Optional(Type.String({ description: "Optional repository path override" })),
+    provider: Type.Optional(Type.String({ description: "Optional explicit repository provider" })),
+    targetRef: Type.Optional(Type.String({ description: "Optional explicit repository target reference, like owner/repo" })),
+    description: Type.Optional(Type.String({ description: "Optional project description" })),
+    priority: Type.Optional(StringEnum(PROJECT_PRIORITY_VALUES, { description: "Optional project priority" })),
+});
+const createProjectCheckToolDefinition = ({ getProjectIntegrationService, }) => ({
+    name: "project_check",
+    label: "Project Check",
+    description: "Check whether a repository is registered to a project.",
+    promptSnippet: "Check whether a repository is registered through the integration-aware project service.",
+    promptGuidelines: [
+        "Use this tool for repository-aware registration checks in normal chat.",
+        "Keep project_check read-only and return explicit registered, not-registered, or ambiguous states.",
+        "Explicit repositoryPath, provider, and targetRef inputs override ambient repo detection where applicable.",
+    ],
+    parameters: ProjectCheckParams,
+    async execute(_toolCallId, params) {
+        try {
+            const input = normalizeProjectCheckInput(params);
+            const projectIntegrationService = await getProjectIntegrationService();
+            const result = await projectIntegrationService.checkRepositoryBinding(input);
+            const details = mapProjectCheckDetails(result, input.repositoryPath);
+            return {
+                content: [{ type: "text", text: formatProjectCheckContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "project_check failed"), { cause: error });
+        }
+    },
+});
+const createProjectRegisterToolDefinition = ({ getProjectIntegrationService, getProjectService, }) => ({
+    name: "project_register",
+    label: "Project Register",
+    description: "Register a repository-backed project through integration-aware services.",
+    promptSnippet: "Register a repository-backed project without collapsing repo registration into plain project_create.",
+    promptGuidelines: [
+        "Use this tool only for repository-aware project registration in normal chat.",
+        "Do not use project_register as a synonym for plain local project_create.",
+        "Report name conflicts, duplicate bindings, ambiguous remotes, and missing repository context explicitly.",
+        "Explicit repositoryPath, provider, and targetRef inputs override ambient repo detection where applicable.",
+    ],
+    parameters: ProjectRegisterParams,
+    async execute(_toolCallId, params) {
+        try {
+            const input = normalizeProjectRegisterInput(params);
+            const projectIntegrationService = await getProjectIntegrationService();
+            const initialCheck = await projectIntegrationService.checkRepositoryBinding(input);
+            const nameConflict = initialCheck.kind === "not-registered"
+                ? await findProjectNameConflict(getProjectService, input, initialCheck)
+                : null;
+            if (nameConflict) {
+                const details = {
+                    kind: "project_register",
+                    state: "name-conflict",
+                    repositoryPath: input.repositoryPath,
+                    repository: initialCheck.kind === "not-registered" ? initialCheck.repository : undefined,
+                    conflictingProjects: nameConflict,
+                    reason: "project-name-conflict",
+                };
+                return {
+                    content: [{ type: "text", text: formatProjectRegisterContent(details) }],
+                    details,
+                };
+            }
+            const result = await projectIntegrationService.registerRepositoryProject(input);
+            const details = mapProjectRegisterDetails(result, input.repositoryPath);
+            return {
+                content: [{ type: "text", text: formatProjectRegisterContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            if (isProjectConflictError(error)) {
+                const details = {
+                    kind: "project_register",
+                    state: "name-conflict",
+                    repositoryPath: params.repositoryPath?.trim() || undefined,
+                    conflictingProjects: [],
+                    reason: error.message,
+                };
+                return {
+                    content: [{ type: "text", text: formatProjectRegisterContent(details) }],
+                    details,
+                };
+            }
+            throw new Error(formatToolError(error, "project_register failed"), { cause: error });
+        }
+    },
+});
+const registerProjectIntegrationTools = (pi, dependencies) => {
+    pi.registerTool(createProjectCheckToolDefinition(dependencies));
+    pi.registerTool(createProjectRegisterToolDefinition(dependencies));
+};
+const normalizeProjectCheckInput = (params) => ({
+    repositoryPath: normalizeOptionalText(params.repositoryPath),
+    provider: normalizeOptionalText(params.provider),
+    targetRef: normalizeOptionalText(params.targetRef),
+});
+const normalizeProjectRegisterInput = (params) => ({
+    projectName: normalizeOptionalText(params.projectName),
+    repositoryPath: normalizeOptionalText(params.repositoryPath),
+    provider: normalizeOptionalText(params.provider),
+    targetRef: normalizeOptionalText(params.targetRef),
+    description: hasOwn(params, "description")
+        ? normalizeNullableText(params.description)
+        : undefined,
+    priority: params.priority,
+});
+const mapProjectCheckDetails = (result, repositoryPath) => {
+    switch (result.kind) {
+        case "registered":
+            return {
+                kind: "project_check",
+                state: "registered",
+                repositoryPath,
+                repository: result.repository,
+                project: result.project,
+                binding: result.binding,
+            };
+        case "not-registered":
+            return {
+                kind: "project_check",
+                state: "not-registered",
+                repositoryPath,
+                repository: result.repository,
+            };
+        case "ambiguous":
+            return {
+                kind: "project_check",
+                state: "ambiguous",
+                repositoryPath: result.repositoryPath ?? repositoryPath,
+                repository: result.repository,
+                bindings: result.bindings,
+                remotes: result.remotes,
+                reason: result.reason,
+            };
+        case "missing-context":
+            return {
+                kind: "project_check",
+                state: "missing-context",
+                repositoryPath: result.repositoryPath ?? repositoryPath,
+                reason: result.reason,
+            };
+        case "unsupported":
+            return {
+                kind: "project_check",
+                state: "unsupported",
+                repositoryPath: result.repositoryPath ?? repositoryPath,
+                reason: result.reason,
+            };
+    }
+};
+const mapProjectRegisterDetails = (result, repositoryPath) => {
+    if (result.kind === "registered" && "createdProject" in result) {
+        return {
+            kind: "project_register",
+            state: "registered",
+            repositoryPath,
+            repository: result.repository,
+            project: result.project,
+            binding: result.binding,
+            createdProject: result.createdProject,
+            createdBinding: result.createdBinding,
+        };
+    }
+    switch (result.kind) {
+        case "already-registered":
+            return {
+                kind: "project_register",
+                state: "already-registered",
+                repositoryPath,
+                repository: result.repository,
+                project: result.project,
+                binding: result.binding,
+            };
+        case "ambiguous":
+            return {
+                kind: "project_register",
+                state: "ambiguous",
+                repositoryPath: result.repositoryPath ?? repositoryPath,
+                repository: result.repository,
+                bindings: result.bindings,
+                remotes: result.remotes,
+                reason: result.reason,
+            };
+        case "missing-context":
+            return {
+                kind: "project_register",
+                state: "missing-context",
+                repositoryPath: result.repositoryPath ?? repositoryPath,
+                reason: result.reason,
+            };
+        case "unsupported":
+            return {
+                kind: "project_register",
+                state: "unsupported",
+                repositoryPath: result.repositoryPath ?? repositoryPath,
+                reason: result.reason,
+            };
+        case "not-registered":
+            return {
+                kind: "project_register",
+                state: "missing-context",
+                repositoryPath,
+                repository: result.repository,
+                reason: "not-registered",
+            };
+        case "registered":
+            return {
+                kind: "project_register",
+                state: "already-registered",
+                repositoryPath,
+                repository: result.repository,
+                project: result.project,
+                binding: result.binding,
+            };
+    }
+};
+const findProjectNameConflict = async (getProjectService, input, result) => {
+    const requestedName = normalizeProjectRegisterName(input.projectName, result.repository.targetRef);
+    const projectService = await getProjectService();
+    const projects = await projectService.listProjects();
+    const matches = projects.filter((project) => project.name === requestedName);
+    return matches.length > 0 ? matches : null;
+};
+const normalizeProjectRegisterName = (projectName, targetRef) => {
+    const trimmedName = projectName?.trim();
+    if (trimmedName && trimmedName.length > 0) {
+        return trimmedName;
+    }
+    const segments = targetRef.split("/");
+    return segments[segments.length - 1] ?? targetRef;
+};
+const formatProjectCheckContent = (details) => {
+    switch (details.state) {
+        case "registered":
+            return [
+                "Registration: Registered",
+                `Project: ${details.project?.name ?? details.binding?.projectId ?? "(missing project)"}`,
+                `Provider: ${details.repository?.provider ?? "-"}`,
+                `Repository: ${details.repository?.targetRef ?? "-"}`,
+                `Integration ID: ${details.binding?.id ?? "-"}`,
+            ].join("\n");
+        case "not-registered":
+            return [
+                "Registration: Not Registered",
+                `Provider: ${details.repository?.provider ?? "-"}`,
+                `Repository: ${details.repository?.targetRef ?? "-"}`,
+                "Integration ID: -",
+            ].join("\n");
+        case "ambiguous":
+            return [
+                "Registration: Ambiguous",
+                `Reason: ${details.reason ?? "ambiguous"}`,
+                details.remotes ? `Remotes: ${details.remotes.join(", ")}` : null,
+                details.bindings
+                    ? `Matching Bindings: ${details.bindings.map((binding) => binding.id).join(", ")}`
+                    : null,
+            ]
+                .filter((value) => value !== null)
+                .join("\n");
+        case "missing-context":
+            return `Registration: Missing Repository Context\nReason: ${details.reason ?? "missing-context"}`;
+        case "unsupported":
+            return `Registration: Unsupported Repository Remote\nReason: ${details.reason ?? "unsupported-remote-format"}`;
+    }
+};
+const formatProjectRegisterContent = (details) => {
+    switch (details.state) {
+        case "registered":
+            return [
+                `Registered project ${details.project?.id ?? "-"}: ${details.project?.name ?? "-"}`,
+                `Provider: ${details.repository?.provider ?? "-"}`,
+                `Repository: ${details.repository?.targetRef ?? "-"}`,
+                `Integration ID: ${details.binding?.id ?? "-"}`,
+            ].join("\n");
+        case "already-registered":
+            return [
+                "Repository is already registered.",
+                `Project: ${details.project?.name ?? details.binding?.projectId ?? "(missing project)"}`,
+                `Provider: ${details.repository?.provider ?? "-"}`,
+                `Repository: ${details.repository?.targetRef ?? "-"}`,
+            ].join("\n");
+        case "name-conflict":
+            return [
+                "Repository registration blocked by project name conflict.",
+                details.conflictingProjects && details.conflictingProjects.length > 0
+                    ? `Conflicting Projects: ${details.conflictingProjects.map((project) => `${project.id} (${project.name})`).join(", ")}`
+                    : null,
+                details.reason ? `Reason: ${details.reason}` : null,
+            ]
+                .filter((value) => value !== null)
+                .join("\n");
+        case "ambiguous":
+            return [
+                "Repository registration is ambiguous.",
+                `Reason: ${details.reason ?? "ambiguous"}`,
+                details.remotes ? `Remotes: ${details.remotes.join(", ")}` : null,
+                details.bindings
+                    ? `Matching Bindings: ${details.bindings.map((binding) => binding.id).join(", ")}`
+                    : null,
+            ]
+                .filter((value) => value !== null)
+                .join("\n");
+        case "missing-context":
+            return `Repository registration requires repository context.\nReason: ${details.reason ?? "missing-context"}`;
+        case "unsupported":
+            return `Repository registration failed for an unsupported remote.\nReason: ${details.reason ?? "unsupported-remote-format"}`;
+    }
+};
+const normalizeOptionalText = (value) => {
+    const trimmedValue = value?.trim();
+    return trimmedValue && trimmedValue.length > 0 ? trimmedValue : undefined;
+};
+const normalizeNullableText = (value) => {
+    const trimmedValue = value?.trim() ?? "";
+    return trimmedValue.length > 0 ? trimmedValue : null;
+};
+const hasOwn = (value, property) => Object.prototype.hasOwnProperty.call(value, property);
+const isProjectConflictError = (error) => (error instanceof ToduProjectServiceError ||
+    error instanceof ToduProjectIntegrationServiceError) &&
+    error.causeCode === "conflict";
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createProjectCheckToolDefinition, createProjectRegisterToolDefinition, formatProjectCheckContent, formatProjectRegisterContent, normalizeProjectCheckInput, normalizeProjectRegisterInput, registerProjectIntegrationTools, };

package/dist/tools/project-mutation-tools.d.ts

@@ -0,0 +1,100 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ProjectSummary, TaskPriority } from "../domain/task";
+import type { CreateProjectInput, DeleteProjectResult, ProjectService, UpdateProjectInput } from "../services/project-service";
+interface ProjectCreateToolParams {
+    name: string;
+    description?: string;
+    priority?: TaskPriority;
+}
+interface ProjectUpdateToolParams {
+    projectId: string;
+    name?: string;
+    description?: string;
+    status?: ProjectSummary["status"];
+    priority?: TaskPriority;
+}
+interface ProjectDeleteToolParams {
+    projectId: string;
+}
+interface ProjectCreateToolDetails {
+    kind: "project_create";
+    input: CreateProjectInput;
+    project: ProjectSummary;
+}
+interface ProjectUpdateToolDetails {
+    kind: "project_update";
+    input: UpdateProjectInput;
+    project: ProjectSummary;
+}
+interface ProjectDeleteToolDetails {
+    kind: "project_delete";
+    projectId: string;
+    found: boolean;
+    deleted: boolean;
+    project?: DeleteProjectResult;
+}
+interface ProjectMutationToolDependencies {
+    getProjectService: () => Promise<ProjectService>;
+}
+declare const createProjectCreateToolDefinition: ({ getProjectService, }: ProjectMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        priority: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"low" | "medium" | "high">>;
+    }>;
+    execute(_toolCallId: string, params: ProjectCreateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: ProjectCreateToolDetails;
+    }>;
+};
+declare const createProjectUpdateToolDefinition: ({ getProjectService, }: ProjectMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        projectId: import("@sinclair/typebox").TString;
+        name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"active" | "done" | "cancelled">>;
+        priority: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<"low" | "medium" | "high">>;
+    }>;
+    execute(_toolCallId: string, params: ProjectUpdateToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: ProjectUpdateToolDetails;
+    }>;
+};
+declare const createProjectDeleteToolDefinition: ({ getProjectService, }: ProjectMutationToolDependencies) => {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    promptGuidelines: string[];
+    parameters: import("@sinclair/typebox").TObject<{
+        projectId: import("@sinclair/typebox").TString;
+    }>;
+    execute(_toolCallId: string, params: ProjectDeleteToolParams): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: ProjectDeleteToolDetails;
+    }>;
+};
+declare const registerProjectMutationTools: (pi: Pick<ExtensionAPI, "registerTool">, dependencies: ProjectMutationToolDependencies) => void;
+declare const normalizeCreateProjectInput: (params: ProjectCreateToolParams) => CreateProjectInput;
+declare const normalizeUpdateProjectInput: (params: ProjectUpdateToolParams) => UpdateProjectInput;
+export type { ProjectCreateToolDetails, ProjectMutationToolDependencies, ProjectUpdateToolDetails, ProjectDeleteToolDetails, };
+export { createProjectCreateToolDefinition, createProjectDeleteToolDefinition, createProjectUpdateToolDefinition, normalizeCreateProjectInput, normalizeUpdateProjectInput, registerProjectMutationTools, };

package/dist/tools/project-mutation-tools.js

@@ -0,0 +1,205 @@
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { ToduProjectServiceError } from "../services/todu/todu-project-service.js";
+const PROJECT_STATUS_VALUES = ["active", "done", "cancelled"];
+const PROJECT_PRIORITY_VALUES = ["low", "medium", "high"];
+const ProjectCreateParams = Type.Object({
+    name: Type.String({ description: "Project name" }),
+    description: Type.Optional(Type.String({ description: "Optional project description" })),
+    priority: Type.Optional(StringEnum(PROJECT_PRIORITY_VALUES, { description: "Optional project priority" })),
+});
+const ProjectUpdateParams = Type.Object({
+    projectId: Type.String({ description: "Project ID" }),
+    name: Type.Optional(Type.String({ description: "Optional replacement project name" })),
+    description: Type.Optional(Type.String({
+        description: "Optional replacement description. Use an empty string to clear it.",
+    })),
+    status: Type.Optional(StringEnum(PROJECT_STATUS_VALUES, { description: "Optional next project status" })),
+    priority: Type.Optional(StringEnum(PROJECT_PRIORITY_VALUES, { description: "Optional next project priority" })),
+});
+const ProjectDeleteParams = Type.Object({
+    projectId: Type.String({ description: "Project ID" }),
+});
+const createProjectCreateToolDefinition = ({ getProjectService, }) => ({
+    name: "project_create",
+    label: "Project Create",
+    description: "Create a plain project record.",
+    promptSnippet: "Create a plain project record through the native project service.",
+    promptGuidelines: [
+        "Use this tool for plain project record creation in normal chat.",
+        "Do not use it for repository registration or integration-binding behavior.",
+    ],
+    parameters: ProjectCreateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const input = normalizeCreateProjectInput(params);
+            const projectService = await getProjectService();
+            const project = await projectService.createProject(input);
+            const details = {
+                kind: "project_create",
+                input,
+                project,
+            };
+            return {
+                content: [{ type: "text", text: formatProjectCreateContent(project) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "project_create failed"), { cause: error });
+        }
+    },
+});
+const createProjectUpdateToolDefinition = ({ getProjectService, }) => ({
+    name: "project_update",
+    label: "Project Update",
+    description: "Update a plain project's name, description, status, or priority.",
+    promptSnippet: "Update a plain project record by explicit project ID.",
+    promptGuidelines: [
+        "Use this tool for plain project-record updates in normal chat.",
+        "Supported fields are name, description, status, and priority.",
+        "Do not use it for repo inspection or integration-binding changes.",
+    ],
+    parameters: ProjectUpdateParams,
+    async execute(_toolCallId, params) {
+        try {
+            const input = normalizeUpdateProjectInput(params);
+            const projectService = await getProjectService();
+            const project = await projectService.updateProject(input);
+            const details = {
+                kind: "project_update",
+                input,
+                project,
+            };
+            return {
+                content: [{ type: "text", text: formatProjectUpdateContent(project, input) }],
+                details,
+            };
+        }
+        catch (error) {
+            throw new Error(formatToolError(error, "project_update failed"), { cause: error });
+        }
+    },
+});
+const createProjectDeleteToolDefinition = ({ getProjectService, }) => ({
+    name: "project_delete",
+    label: "Project Delete",
+    description: "Delete a plain project record by explicit project ID.",
+    promptSnippet: "Delete a plain project record by explicit project ID.",
+    promptGuidelines: [
+        "Use this tool for plain project deletion in normal chat.",
+        "Do not use it for repository unregister or integration-binding changes.",
+    ],
+    parameters: ProjectDeleteParams,
+    async execute(_toolCallId, params) {
+        const projectId = normalizeRequiredText(params.projectId, "projectId");
+        try {
+            const projectService = await getProjectService();
+            const project = await projectService.deleteProject(projectId);
+            const details = {
+                kind: "project_delete",
+                projectId,
+                found: true,
+                deleted: true,
+                project,
+            };
+            return {
+                content: [{ type: "text", text: formatProjectDeleteContent(details) }],
+                details,
+            };
+        }
+        catch (error) {
+            if (isProjectNotFoundError(error)) {
+                const details = {
+                    kind: "project_delete",
+                    projectId,
+                    found: false,
+                    deleted: false,
+                };
+                return {
+                    content: [{ type: "text", text: formatProjectDeleteContent(details) }],
+                    details,
+                };
+            }
+            throw new Error(formatToolError(error, "project_delete failed"), { cause: error });
+        }
+    },
+});
+const registerProjectMutationTools = (pi, dependencies) => {
+    pi.registerTool(createProjectCreateToolDefinition(dependencies));
+    pi.registerTool(createProjectUpdateToolDefinition(dependencies));
+    pi.registerTool(createProjectDeleteToolDefinition(dependencies));
+};
+const normalizeCreateProjectInput = (params) => ({
+    name: normalizeRequiredText(params.name, "name"),
+    description: normalizeOptionalDescription(params, "description"),
+    priority: params.priority,
+});
+const normalizeUpdateProjectInput = (params) => {
+    const input = {
+        projectId: normalizeRequiredText(params.projectId, "projectId"),
+        status: params.status,
+        priority: params.priority,
+    };
+    if (hasOwn(params, "name")) {
+        input.name = normalizeRequiredText(params.name ?? "", "name");
+    }
+    if (hasOwn(params, "description")) {
+        input.description = normalizeNullableText(params.description);
+    }
+    if (input.name === undefined &&
+        input.status === undefined &&
+        input.priority === undefined &&
+        !hasOwn(input, "description")) {
+        throw new Error("project_update requires at least one supported field: name, description, status, or priority");
+    }
+    return input;
+};
+const normalizeOptionalDescription = (params, fieldName) => {
+    if (!hasOwn(params, fieldName)) {
+        return undefined;
+    }
+    return normalizeNullableText(params[fieldName]);
+};
+const normalizeRequiredText = (value, fieldName) => {
+    const trimmedValue = value.trim();
+    if (trimmedValue.length === 0) {
+        throw new Error(`${fieldName} is required`);
+    }
+    return trimmedValue;
+};
+const normalizeNullableText = (value) => {
+    const trimmedValue = value?.trim() ?? "";
+    return trimmedValue.length > 0 ? trimmedValue : null;
+};
+const hasOwn = (value, property) => Object.prototype.hasOwnProperty.call(value, property);
+const isProjectNotFoundError = (error) => error instanceof ToduProjectServiceError && error.causeCode === "not-found";
+const formatProjectCreateContent = (project) => [
+    `Created project ${project.id}: ${project.name}`,
+    `Status: ${project.status}`,
+    `Priority: ${project.priority}`,
+].join("\n");
+const formatProjectUpdateContent = (project, input) => {
+    const changedFields = [
+        input.name !== undefined ? `name=${JSON.stringify(input.name)}` : null,
+        input.status !== undefined ? `status=${input.status}` : null,
+        input.priority !== undefined ? `priority=${input.priority}` : null,
+        hasOwn(input, "description")
+            ? `description=${input.description === null ? "cleared" : "updated"}`
+            : null,
+    ].filter((value) => value !== null);
+    return [
+        `Updated project ${project.id}: ${project.name}`,
+        `Changes: ${changedFields.join(", ")}`,
+    ].join("\n");
+};
+const formatProjectDeleteContent = (details) => details.found
+    ? `Deleted project ${details.projectId}.`
+    : `Project not found: ${details.projectId}`;
+const formatToolError = (error, prefix) => {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return `${prefix}: ${error.message}`;
+    }
+    return prefix;
+};
+export { createProjectCreateToolDefinition, createProjectDeleteToolDefinition, createProjectUpdateToolDefinition, normalizeCreateProjectInput, normalizeUpdateProjectInput, registerProjectMutationTools, };