@vibescope/mcp-server 0.1.0 → 0.2.1

package/dist/handlers/fallback.js

@@ -9,7 +9,7 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { FALLBACK_ACTIVITIES } from '../utils.js';
 import { getApiClient } from '../api-client.js';
 const VALID_ACTIVITIES = [
@@ -24,14 +24,25 @@ const VALID_ACTIVITIES = [
     'dependency_audit',
     'validate_completed_tasks',
 ];
+// Argument schemas for type-safe parsing
+const startFallbackActivitySchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    activity: { type: 'string', required: true, validate: createEnumValidator(VALID_ACTIVITIES) },
+};
+const stopFallbackActivitySchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    summary: { type: 'string' },
+};
+const getActivityHistorySchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    activity_type: { type: 'string' },
+    limit: { type: 'number', default: 50 },
+};
+const getActivitySchedulesSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
 export const startFallbackActivity = async (args, ctx) => {
-    const { project_id, activity } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(activity, 'activity');
-    if (!VALID_ACTIVITIES.includes(activity)) {
-        throw new Error(`Invalid activity. Must be one of: ${VALID_ACTIVITIES.join(', ')}`);
-    }
+    const { project_id, activity } = parseArgs(args, startFallbackActivitySchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.startFallbackActivity(project_id, activity, session.currentSessionId || undefined);
@@ -40,21 +51,28 @@ export const startFallbackActivity = async (args, ctx) => {
     }
     // Get the activity details for the response
     const activityInfo = FALLBACK_ACTIVITIES.find((a) => a.activity === activity);
-    return {
-        result: {
-            success: true,
-            activity,
-            title: activityInfo?.title || activity,
-            description: activityInfo?.description || '',
-            prompt: activityInfo?.prompt || '',
-            message: response.data?.message || `Started fallback activity: ${activityInfo?.title || activity}`,
-        },
+    const result = {
+        success: true,
+        activity,
+        title: activityInfo?.title || activity,
+        description: activityInfo?.description || '',
+        prompt: activityInfo?.prompt || '',
+        message: response.data?.message || `Started fallback activity: ${activityInfo?.title || activity}`,
     };
+    // Pass through worktree guidance if provided
+    if (response.data?.git_workflow) {
+        result.git_workflow = response.data.git_workflow;
+    }
+    if (response.data?.worktree_setup) {
+        result.worktree_setup = response.data.worktree_setup;
+    }
+    if (response.data?.next_step) {
+        result.next_step = response.data.next_step;
+    }
+    return { result };
 };
 export const stopFallbackActivity = async (args, ctx) => {
-    const { project_id, summary } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, summary } = parseArgs(args, stopFallbackActivitySchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.stopFallbackActivity(project_id, summary, session.currentSessionId || undefined);
@@ -68,10 +86,8 @@ export const stopFallbackActivity = async (args, ctx) => {
         },
     };
 };
-export const getActivityHistory = async (args, ctx) => {
-    const { project_id, activity_type, limit = 50 } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const getActivityHistory = async (args, _ctx) => {
+    const { project_id, activity_type, limit } = parseArgs(args, getActivityHistorySchema);
     const apiClient = getApiClient();
     // Use proxy for get_activity_history operation
     const response = await apiClient.proxy('get_activity_history', {
@@ -90,10 +106,8 @@ export const getActivityHistory = async (args, ctx) => {
         },
     };
 };
-export const getActivitySchedules = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const getActivitySchedules = async (args, _ctx) => {
+    const { project_id } = parseArgs(args, getActivitySchedulesSchema);
     const apiClient = getApiClient();
     // Use proxy for get_activity_schedules operation
     const response = await apiClient.proxy('get_activity_schedules', {

package/dist/handlers/file-checkouts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * File Checkouts Handlers
+ *
+ * Handles file checkout/checkin for multi-agent coordination:
+ * - checkout_file: Check out a file before editing
+ * - checkin_file: Check in a file after editing
+ * - get_file_checkouts: Get active checkouts for a project
+ * - abandon_checkout: Force release a checkout
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+export declare const checkoutFile: Handler;
+export declare const checkinFile: Handler;
+export declare const getFileCheckouts: Handler;
+export declare const abandonCheckout: Handler;
+/**
+ * File Checkouts handlers registry
+ */
+export declare const fileCheckoutHandlers: HandlerRegistry;

package/dist/handlers/file-checkouts.js

@@ -0,0 +1,101 @@
+/**
+ * File Checkouts Handlers
+ *
+ * Handles file checkout/checkin for multi-agent coordination:
+ * - checkout_file: Check out a file before editing
+ * - checkin_file: Check in a file after editing
+ * - get_file_checkouts: Get active checkouts for a project
+ * - abandon_checkout: Force release a checkout
+ */
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
+import { getApiClient } from '../api-client.js';
+const VALID_CHECKOUT_STATUSES = ['checked_out', 'checked_in', 'abandoned'];
+// Argument schemas for type-safe parsing
+const checkoutFileSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    file_path: { type: 'string', required: true },
+    reason: { type: 'string' },
+};
+const checkinFileSchema = {
+    checkout_id: { type: 'string', validate: uuidValidator },
+    project_id: { type: 'string', validate: uuidValidator },
+    file_path: { type: 'string' },
+    summary: { type: 'string' },
+};
+const getFileCheckoutsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(VALID_CHECKOUT_STATUSES) },
+    file_path: { type: 'string' },
+    limit: { type: 'number', default: 50 },
+};
+const abandonCheckoutSchema = {
+    checkout_id: { type: 'string', validate: uuidValidator },
+    project_id: { type: 'string', validate: uuidValidator },
+    file_path: { type: 'string' },
+};
+export const checkoutFile = async (args, ctx) => {
+    const { project_id, file_path, reason } = parseArgs(args, checkoutFileSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.checkoutFile(project_id, file_path, reason, ctx.session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to checkout file');
+    }
+    return { result: response.data };
+};
+export const checkinFile = async (args, ctx) => {
+    const { checkout_id, project_id, file_path, summary } = parseArgs(args, checkinFileSchema);
+    // Validate that either checkout_id or both project_id and file_path are provided
+    if (!checkout_id && (!project_id || !file_path)) {
+        throw new Error('Either checkout_id or both project_id and file_path are required');
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.checkinFile({
+        checkout_id,
+        project_id,
+        file_path,
+        summary
+    }, ctx.session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to checkin file');
+    }
+    return { result: response.data };
+};
+export const getFileCheckouts = async (args, _ctx) => {
+    const { project_id, status, file_path, limit } = parseArgs(args, getFileCheckoutsSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.getFileCheckouts(project_id, {
+        status,
+        file_path,
+        limit
+    });
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to get file checkouts');
+    }
+    return { result: response.data };
+};
+export const abandonCheckout = async (args, _ctx) => {
+    const { checkout_id, project_id, file_path } = parseArgs(args, abandonCheckoutSchema);
+    // Validate that either checkout_id or both project_id and file_path are provided
+    if (!checkout_id && (!project_id || !file_path)) {
+        throw new Error('Either checkout_id or both project_id and file_path are required');
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.abandonCheckout({
+        checkout_id,
+        project_id,
+        file_path
+    });
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to abandon checkout');
+    }
+    return { result: response.data };
+};
+/**
+ * File Checkouts handlers registry
+ */
+export const fileCheckoutHandlers = {
+    checkout_file: checkoutFile,
+    checkin_file: checkinFile,
+    get_file_checkouts: getFileCheckouts,
+    abandon_checkout: abandonCheckout,
+};

package/dist/handlers/findings.d.ts

@@ -3,15 +3,28 @@
  *
  * Handles audit findings and knowledge base:
  * - add_finding
- * - get_findings
+ * - get_findings (supports summary_only for reduced tokens)
+ * - get_findings_stats (aggregate counts for minimal tokens)
  * - update_finding
  * - delete_finding
  */
 import type { Handler, HandlerRegistry } from './types.js';
 export declare const addFinding: Handler;
 export declare const getFindings: Handler;
+/**
+ * Get aggregate statistics about findings for a project.
+ * Returns counts by category, severity, and status without the actual finding data.
+ * This is much more token-efficient than get_findings for understanding the overall state.
+ */
+export declare const getFindingsStats: Handler;
 export declare const updateFinding: Handler;
 export declare const deleteFinding: Handler;
+/**
+ * Query aggregated project knowledge in a single call.
+ * Returns findings, Q&A, decisions, completed tasks, and resolved blockers.
+ * Use this instead of multiple separate tool calls to reduce token usage.
+ */
+export declare const queryKnowledgeBase: Handler;
 /**
  * Findings handlers registry
  */

package/dist/handlers/findings.js

@@ -3,25 +3,67 @@
  *
  * Handles audit findings and knowledge base:
  * - add_finding
- * - get_findings
+ * - get_findings (supports summary_only for reduced tokens)
+ * - get_findings_stats (aggregate counts for minimal tokens)
  * - update_finding
  * - delete_finding
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const VALID_FINDING_CATEGORIES = ['performance', 'security', 'code_quality', 'accessibility', 'documentation', 'architecture', 'testing', 'other'];
+const VALID_FINDING_SEVERITIES = ['info', 'low', 'medium', 'high', 'critical'];
+const VALID_FINDING_STATUSES = ['open', 'addressed', 'dismissed', 'wontfix'];
+// Argument schemas for type-safe parsing
+const addFindingSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    category: { type: 'string', validate: createEnumValidator(VALID_FINDING_CATEGORIES) },
+    severity: { type: 'string', validate: createEnumValidator(VALID_FINDING_SEVERITIES) },
+    file_path: { type: 'string' },
+    line_number: { type: 'number' },
+    related_task_id: { type: 'string', validate: uuidValidator },
+};
+const getFindingsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    category: { type: 'string', validate: createEnumValidator(VALID_FINDING_CATEGORIES) },
+    severity: { type: 'string', validate: createEnumValidator(VALID_FINDING_SEVERITIES) },
+    status: { type: 'string', validate: createEnumValidator(VALID_FINDING_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+    summary_only: { type: 'boolean', default: false },
+};
+const getFindingsStatsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const updateFindingSchema = {
+    finding_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    severity: { type: 'string', validate: createEnumValidator(VALID_FINDING_SEVERITIES) },
+    status: { type: 'string', validate: createEnumValidator(VALID_FINDING_STATUSES) },
+    resolution_note: { type: 'string' },
+};
+const deleteFindingSchema = {
+    finding_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const VALID_SCOPES = ['summary', 'detailed'];
+const queryKnowledgeBaseSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    scope: { type: 'string', default: 'summary', validate: createEnumValidator(VALID_SCOPES) },
+    categories: { type: 'array' },
+    limit: { type: 'number', default: 5 },
+    search_query: { type: 'string' },
+};
 export const addFinding = async (args, ctx) => {
-    const { project_id, category, title, description, severity, file_path, line_number, related_task_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(title, 'title');
-    if (related_task_id)
-        validateUUID(related_task_id, 'related_task_id');
+    const { project_id, title, description, category, severity, file_path, line_number, related_task_id } = parseArgs(args, addFindingSchema);
     const apiClient = getApiClient();
     const response = await apiClient.addFinding(project_id, {
         title,
         description,
-        category,
-        severity,
+        category: category,
+        severity: severity,
         file_path,
         line_number,
         related_task_id
@@ -31,32 +73,45 @@ export const addFinding = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const getFindings = async (args, ctx) => {
-    const { project_id, category, severity, status, limit = 50, offset = 0, search_query } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const getFindings = async (args, _ctx) => {
+    const { project_id, category, severity, status, limit, offset, search_query, summary_only } = parseArgs(args, getFindingsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getFindings(project_id, {
-        category,
-        severity,
-        status,
-        limit
+        category: category,
+        severity: severity,
+        status: status,
+        limit,
+        offset,
+        search_query,
+        summary_only
     });
     if (!response.ok) {
         throw new Error(response.error || 'Failed to get findings');
     }
     return { result: response.data };
 };
-export const updateFinding = async (args, ctx) => {
-    const { finding_id, status, resolution_note, title, description, severity } = args;
-    validateRequired(finding_id, 'finding_id');
-    validateUUID(finding_id, 'finding_id');
+/**
+ * Get aggregate statistics about findings for a project.
+ * Returns counts by category, severity, and status without the actual finding data.
+ * This is much more token-efficient than get_findings for understanding the overall state.
+ */
+export const getFindingsStats = async (args, _ctx) => {
+    const { project_id } = parseArgs(args, getFindingsStatsSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.getFindingsStats(project_id);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to get findings stats');
+    }
+    return { result: response.data };
+};
+export const updateFinding = async (args, _ctx) => {
+    const { finding_id, title, description, severity, status, resolution_note } = parseArgs(args, updateFindingSchema);
     const apiClient = getApiClient();
     const response = await apiClient.updateFinding(finding_id, {
         title,
         description,
-        severity,
-        status,
+        severity: severity,
+        status: status,
         resolution_note
     });
     if (!response.ok) {
@@ -64,10 +119,8 @@ export const updateFinding = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const deleteFinding = async (args, ctx) => {
-    const { finding_id } = args;
-    validateRequired(finding_id, 'finding_id');
-    validateUUID(finding_id, 'finding_id');
+export const deleteFinding = async (args, _ctx) => {
+    const { finding_id } = parseArgs(args, deleteFindingSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteFinding(finding_id);
     if (!response.ok) {
@@ -75,12 +128,35 @@ export const deleteFinding = async (args, ctx) => {
     }
     return { result: response.data };
 };
+/**
+ * Query aggregated project knowledge in a single call.
+ * Returns findings, Q&A, decisions, completed tasks, and resolved blockers.
+ * Use this instead of multiple separate tool calls to reduce token usage.
+ */
+export const queryKnowledgeBase = async (args, _ctx) => {
+    const { project_id, scope, categories, limit, search_query } = parseArgs(args, queryKnowledgeBaseSchema);
+    // Validate limit range
+    const effectiveLimit = Math.min(Math.max(1, limit ?? 5), 20);
+    const apiClient = getApiClient();
+    const response = await apiClient.queryKnowledgeBase(project_id, {
+        scope: scope,
+        categories: categories,
+        limit: effectiveLimit,
+        search_query
+    });
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to query knowledge base');
+    }
+    return { result: response.data };
+};
 /**
  * Findings handlers registry
  */
 export const findingHandlers = {
     add_finding: addFinding,
     get_findings: getFindings,
+    get_findings_stats: getFindingsStats,
     update_finding: updateFinding,
     delete_finding: deleteFinding,
+    query_knowledge_base: queryKnowledgeBase,
 };

package/dist/handlers/git-issues.js

@@ -7,7 +7,7 @@
  * - get_git_issues: List git issues for a project
  * - delete_git_issue: Remove a git issue
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 const VALID_GIT_ISSUE_TYPES = [
     'merge_conflict',
@@ -17,25 +17,41 @@ const VALID_GIT_ISSUE_TYPES = [
     'pr_not_mergeable',
 ];
 const VALID_GIT_ISSUE_STATUSES = ['open', 'resolved'];
+// Argument schemas for type-safe parsing
+const addGitIssueSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    issue_type: { type: 'string', required: true, validate: createEnumValidator(VALID_GIT_ISSUE_TYPES) },
+    branch: { type: 'string', required: true },
+    target_branch: { type: 'string' },
+    pr_url: { type: 'string' },
+    conflicting_files: { type: 'array' },
+    error_message: { type: 'string' },
+    task_id: { type: 'string', validate: uuidValidator },
+};
+const resolveGitIssueSchema = {
+    git_issue_id: { type: 'string', required: true, validate: uuidValidator },
+    resolution_note: { type: 'string' },
+    auto_resolved: { type: 'boolean' },
+};
+const getGitIssuesSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', default: 'open', validate: createEnumValidator(VALID_GIT_ISSUE_STATUSES) },
+    issue_type: { type: 'string', validate: createEnumValidator(VALID_GIT_ISSUE_TYPES) },
+    branch: { type: 'string' },
+    limit: { type: 'number', default: 50 },
+};
+const deleteGitIssueSchema = {
+    git_issue_id: { type: 'string', required: true, validate: uuidValidator },
+};
 export const addGitIssue = async (args, ctx) => {
-    const { project_id, issue_type, branch, target_branch, pr_url, conflicting_files, error_message, task_id, } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(issue_type, 'issue_type');
-    validateRequired(branch, 'branch');
-    if (!VALID_GIT_ISSUE_TYPES.includes(issue_type)) {
-        throw new Error(`Invalid issue_type. Valid types: ${VALID_GIT_ISSUE_TYPES.join(', ')}`);
-    }
-    if (task_id) {
-        validateUUID(task_id, 'task_id');
-    }
+    const { project_id, issue_type, branch, target_branch, pr_url, conflicting_files, error_message, task_id } = parseArgs(args, addGitIssueSchema);
     const apiClient = getApiClient();
     const response = await apiClient.addGitIssue(project_id, {
         issue_type: issue_type,
         branch,
         target_branch,
         pr_url,
-        conflicting_files,
+        conflicting_files: conflicting_files,
         error_message,
         task_id
     }, ctx.session.currentSessionId || undefined);
@@ -45,9 +61,7 @@ export const addGitIssue = async (args, ctx) => {
     return { result: response.data };
 };
 export const resolveGitIssue = async (args, ctx) => {
-    const { git_issue_id, resolution_note, auto_resolved } = args;
-    validateRequired(git_issue_id, 'git_issue_id');
-    validateUUID(git_issue_id, 'git_issue_id');
+    const { git_issue_id, resolution_note, auto_resolved } = parseArgs(args, resolveGitIssueSchema);
     const apiClient = getApiClient();
     const response = await apiClient.resolveGitIssue(git_issue_id, {
         resolution_note,
@@ -58,20 +72,12 @@ export const resolveGitIssue = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const getGitIssues = async (args, ctx) => {
-    const { project_id, status = 'open', issue_type, branch, limit = 50, } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (status && !VALID_GIT_ISSUE_STATUSES.includes(status)) {
-        throw new Error(`Invalid status. Valid statuses: ${VALID_GIT_ISSUE_STATUSES.join(', ')}`);
-    }
-    if (issue_type && !VALID_GIT_ISSUE_TYPES.includes(issue_type)) {
-        throw new Error(`Invalid issue_type. Valid types: ${VALID_GIT_ISSUE_TYPES.join(', ')}`);
-    }
+export const getGitIssues = async (args, _ctx) => {
+    const { project_id, status, issue_type, branch, limit } = parseArgs(args, getGitIssuesSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getGitIssues(project_id, {
-        status,
-        issue_type,
+        status: status,
+        issue_type: issue_type,
         branch,
         limit
     });
@@ -80,10 +86,8 @@ export const getGitIssues = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const deleteGitIssue = async (args, ctx) => {
-    const { git_issue_id } = args;
-    validateRequired(git_issue_id, 'git_issue_id');
-    validateUUID(git_issue_id, 'git_issue_id');
+export const deleteGitIssue = async (args, _ctx) => {
+    const { git_issue_id } = parseArgs(args, deleteGitIssueSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteGitIssue(git_issue_id);
     if (!response.ok) {

package/dist/handlers/ideas.js

@@ -10,34 +10,60 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID, validatePriority, validateEstimatedMinutes } from '../validators.js';
+import { parseArgs, uuidValidator, priorityValidator, minutesValidator, createEnumValidator, } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const VALID_IDEA_STATUSES = ['raw', 'exploring', 'planned', 'in_development', 'shipped'];
+// Argument schemas for type-safe parsing
+const addIdeaSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    status: { type: 'string', validate: createEnumValidator(VALID_IDEA_STATUSES) },
+};
+const updateIdeaSchema = {
+    idea_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    status: { type: 'string', validate: createEnumValidator(VALID_IDEA_STATUSES) },
+    doc_url: { type: 'string' },
+};
+const getIdeasSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(VALID_IDEA_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+};
+const deleteIdeaSchema = {
+    idea_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const convertIdeaToTaskSchema = {
+    idea_id: { type: 'string', required: true, validate: uuidValidator },
+    priority: { type: 'number', default: 3, validate: priorityValidator },
+    estimated_minutes: { type: 'number', validate: minutesValidator },
+    update_status: { type: 'boolean', default: true },
+};
 export const addIdea = async (args, ctx) => {
-    const { project_id, title, description, status } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(title, 'title');
+    const { project_id, title, description, status } = parseArgs(args, addIdeaSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.addIdea(project_id, {
         title,
         description,
-        status
+        status: status
     }, session.currentSessionId || undefined);
     if (!response.ok) {
         throw new Error(`Failed to add idea: ${response.error}`);
     }
     return { result: { success: true, idea_id: response.data?.idea_id, title } };
 };
-export const updateIdea = async (args, ctx) => {
-    const { idea_id, title, description, status, doc_url } = args;
-    validateRequired(idea_id, 'idea_id');
-    validateUUID(idea_id, 'idea_id');
+export const updateIdea = async (args, _ctx) => {
+    const { idea_id, title, description, status, doc_url } = parseArgs(args, updateIdeaSchema);
     const apiClient = getApiClient();
     const response = await apiClient.updateIdea(idea_id, {
         title,
         description,
-        status,
+        status: status,
         doc_url
     });
     if (!response.ok) {
@@ -45,13 +71,11 @@ export const updateIdea = async (args, ctx) => {
     }
     return { result: { success: true, idea_id } };
 };
-export const getIdeas = async (args, ctx) => {
-    const { project_id, status, limit = 50, offset = 0, search_query } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const getIdeas = async (args, _ctx) => {
+    const { project_id, status, limit, offset, search_query } = parseArgs(args, getIdeasSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getIdeas(project_id, {
-        status,
+        status: status,
         limit,
         offset,
         search_query
@@ -65,10 +89,8 @@ export const getIdeas = async (args, ctx) => {
         },
     };
 };
-export const deleteIdea = async (args, ctx) => {
-    const { idea_id } = args;
-    validateRequired(idea_id, 'idea_id');
-    validateUUID(idea_id, 'idea_id');
+export const deleteIdea = async (args, _ctx) => {
+    const { idea_id } = parseArgs(args, deleteIdeaSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteIdea(idea_id);
     if (!response.ok) {
@@ -76,12 +98,8 @@ export const deleteIdea = async (args, ctx) => {
     }
     return { result: { success: true } };
 };
-export const convertIdeaToTask = async (args, ctx) => {
-    const { idea_id, priority = 3, estimated_minutes, update_status = true } = args;
-    validateRequired(idea_id, 'idea_id');
-    validateUUID(idea_id, 'idea_id');
-    validatePriority(priority);
-    validateEstimatedMinutes(estimated_minutes);
+export const convertIdeaToTask = async (args, _ctx) => {
+    const { idea_id, priority, estimated_minutes, update_status } = parseArgs(args, convertIdeaToTaskSchema);
     const apiClient = getApiClient();
     // Use proxy for convert_idea_to_task operation
     const response = await apiClient.proxy('convert_idea_to_task', {