@aaronsb/jira-cloud-mcp 0.8.1 → 0.10.0

package/build/handlers/plan-handler.js

@@ -1,16 +1,60 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { searchGoals, getGoalByKey, resolveGoalWorkItems, createGoal, editGoal, createGoalStatusUpdate, linkWorkItem, unlinkWorkItem } from '../client/graphql-goals.js';
 import { GraphQLHierarchyWalker, collectLeaves, computeDepth, walkTree } from '../client/graphql-hierarchy.js';
-import { planNextSteps } from '../utils/next-steps.js';
+import { planNextSteps, goalNextSteps } from '../utils/next-steps.js';
 import { normalizeArgs } from '../utils/normalize-args.js';
 const ALL_ROLLUPS = ['dates', 'points', 'progress', 'assignees'];
 const MAX_CHILDREN_DISPLAY = 20;
 export async function handlePlanRequest(_jiraClient, graphqlClient, request, cache) {
     const args = normalizeArgs(request.params?.arguments ?? {});
+    const operation = args.operation ?? 'analyze';
+    const goalKey = args.goalKey;
+    // Goal operations
+    if (operation === 'list_goals') {
+        return handleListGoals(graphqlClient, args);
+    }
+    if (operation === 'get_goal') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for get_goal');
+        return handleGetGoal(graphqlClient, goalKey);
+    }
+    if (goalKey && operation === 'analyze') {
+        return handleAnalyzeGoal(graphqlClient, goalKey, args, cache);
+    }
+    if (operation === 'create_goal') {
+        return handleCreateGoal(graphqlClient, args);
+    }
+    if (operation === 'update_goal') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for update_goal');
+        return handleUpdateGoal(graphqlClient, goalKey, args);
+    }
+    if (operation === 'update_goal_status') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for update_goal_status');
+        return handleUpdateGoalStatus(graphqlClient, goalKey, args);
+    }
+    if (operation === 'link_work_item') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for link_work_item');
+        const issueKeyArg = args.issueKey;
+        if (!issueKeyArg)
+            throw new McpError(ErrorCode.InvalidParams, 'issueKey is required for link_work_item');
+        return handleLinkWorkItem(graphqlClient, goalKey, issueKeyArg);
+    }
+    if (operation === 'unlink_work_item') {
+        if (!goalKey)
+            throw new McpError(ErrorCode.InvalidParams, 'goalKey is required for unlink_work_item');
+        const issueKeyArg = args.issueKey;
+        if (!issueKeyArg)
+            throw new McpError(ErrorCode.InvalidParams, 'issueKey is required for unlink_work_item');
+        return handleUnlinkWorkItem(graphqlClient, goalKey, issueKeyArg);
+    }
+    // Issue operations require issueKey
     const issueKey = args.issueKey;
     if (!issueKey) {
-        throw new McpError(ErrorCode.InvalidParams, 'issueKey is required for analyze_jira_plan');
+        throw new McpError(ErrorCode.InvalidParams, 'issueKey or goalKey is required for manage_jira_plan');
     }
-    const operation = args.operation ?? 'analyze';
     // Handle release operation
     if (operation === 'release') {
         if (!cache) {
@@ -349,3 +393,264 @@ export function renderRollupTree(node, lines, rollups, prefix, isLast) {
         renderRollupTree(child, lines, rollups, childPrefix, i === node.children.length - 1);
     });
 }
+// --- Goal operations ---
+async function handleListGoals(graphqlClient, args) {
+    const searchString = args.searchString ?? '';
+    const sort = args.sort ?? 'HIERARCHY_ASC';
+    const result = await searchGoals(graphqlClient, searchString, sort);
+    if (!result.success || !result.goals) {
+        const error = result.error ?? 'Unknown error';
+        if (error.includes('not found') || error.includes('Cannot route')) {
+            return { content: [{ type: 'text', text: 'No goals found. Goals may not be enabled on this instance.' }] };
+        }
+        return { content: [{ type: 'text', text: `Goal search failed: ${error}` }], isError: true };
+    }
+    if (result.goals.length === 0) {
+        const hint = searchString.includes('status =')
+            ? '\n\n*Note: TQL status filtering may be incomplete for some values. Try without the status filter to see all goals.*'
+            : '';
+        return { content: [{ type: 'text', text: `No goals found for search: "${searchString}"${hint}` }] };
+    }
+    const lines = [];
+    lines.push(`# Goals (${result.goals.length})`);
+    lines.push('');
+    for (const goal of result.goals) {
+        const workCount = result.workItemCounts?.get(goal.key) ?? 0;
+        const indent = goal.parentGoal ? '  ' : '';
+        const stateIcon = goalStateIcon(goal.state.value);
+        const owner = goal.owner ? ` — ${goal.owner.name}` : '';
+        const workLabel = workCount > 0 ? ` | ${workCount} linked issues` : '';
+        lines.push(`${indent}${stateIcon} **${goal.key}**: ${goal.name} [${goal.state.label}]${owner}${workLabel}`);
+    }
+    lines.push('');
+    lines.push(goalNextSteps('list_goals'));
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleGetGoal(graphqlClient, goalKey) {
+    const result = await getGoalByKey(graphqlClient, goalKey);
+    if (!result.success || !result.goal) {
+        return { content: [{ type: 'text', text: `Goal ${goalKey} not found: ${result.error ?? 'unknown error'}` }], isError: true };
+    }
+    const goal = result.goal;
+    const lines = [];
+    lines.push(`# Goal: ${goal.key} — ${goal.name}`);
+    lines.push(`**State:** ${goal.state.label} | **Owner:** ${goal.owner?.name ?? 'Unassigned'}`);
+    if (goal.parentGoal) {
+        lines.push(`**Parent:** ${goal.parentGoal.key} — ${goal.parentGoal.name}`);
+    }
+    if (goal.description) {
+        lines.push(`**Description:** ${goal.description}`);
+    }
+    lines.push('');
+    if (goal.subGoals.length > 0) {
+        lines.push(`## Sub-Goals (${goal.subGoals.length})`);
+        lines.push('');
+        for (const sg of goal.subGoals) {
+            const stateIcon = goalStateIcon(sg.state.value);
+            lines.push(`${stateIcon} **${sg.key}**: ${sg.name} [${sg.state.label}]`);
+        }
+        lines.push('');
+    }
+    if (goal.projects.length > 0) {
+        lines.push(`## Projects (${goal.projects.length})`);
+        lines.push('');
+        for (const p of goal.projects) {
+            lines.push(`- ${p.name} [${p.state.value}]`);
+        }
+        lines.push('');
+    }
+    if (goal.workItems.length > 0) {
+        lines.push(`## Linked Issues (${goal.workItems.length})`);
+        lines.push('');
+        for (const w of goal.workItems) {
+            lines.push(`- **${w.key}** [${w.issueType.name}] ${w.summary} — ${w.status.name}`);
+        }
+        lines.push('');
+    }
+    else {
+        lines.push('*No linked Jira issues.*');
+        lines.push('');
+    }
+    lines.push(goalNextSteps('get_goal', goalKey, goal.workItems.length));
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleAnalyzeGoal(graphqlClient, goalKey, args, cache) {
+    const result = await resolveGoalWorkItems(graphqlClient, goalKey);
+    if (!result.success || !result.goal) {
+        return { content: [{ type: 'text', text: `Failed to resolve goal ${goalKey}: ${result.error ?? 'unknown error'}` }], isError: true };
+    }
+    const goal = result.goal;
+    const issueKeys = result.issueKeys ?? [];
+    if (issueKeys.length === 0) {
+        const lines = [];
+        lines.push(`# Goal: ${goal.key} — ${goal.name} [${goal.state.label}]`);
+        lines.push('');
+        lines.push('No linked Jira issues to analyze. Cannot resolve linked Jira issues — the workItems API may have changed, or no issues are linked to this goal.');
+        lines.push('');
+        lines.push(goalNextSteps('analyze', goalKey, 0));
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+    // Goal context header
+    const header = [];
+    header.push(`# Goal: ${goal.key} — ${goal.name} [${goal.state.label}]`);
+    header.push(`**Owner:** ${goal.owner?.name ?? 'Unassigned'} | **Linked issues:** ${issueKeys.length}`);
+    if (goal.subGoals.length > 0) {
+        header.push(`**Sub-goals:** ${goal.subGoals.map(sg => `${sg.key} [${sg.state.value}]`).join(', ')}`);
+    }
+    header.push('');
+    // Walk each issue's hierarchy and compute rollups
+    const rollups = (Array.isArray(args.rollups) ? args.rollups : ALL_ROLLUPS);
+    // For goal analysis, walk each linked issue and merge results
+    const walker = new GraphQLHierarchyWalker(graphqlClient);
+    const allTrees = [];
+    const errors = [];
+    // Separate cached from uncached keys
+    const uncachedKeys = [];
+    for (const key of issueKeys) {
+        if (cache) {
+            const status = cache.getStatus(key);
+            if (status.state === 'complete' || status.state === 'stale') {
+                allTrees.push(cache.get(key).tree);
+                continue;
+            }
+        }
+        uncachedKeys.push(key);
+    }
+    // Walk uncached keys in parallel
+    const walkResults = await Promise.allSettled(uncachedKeys.map(key => walker.walkDown(key)));
+    for (let i = 0; i < walkResults.length; i++) {
+        const result = walkResults[i];
+        if (result.status === 'fulfilled') {
+            allTrees.push(result.value.tree);
+        }
+        else {
+            errors.push(uncachedKeys[i]);
+        }
+    }
+    if (allTrees.length === 0) {
+        header.push('All issue hierarchy walks failed. The linked issues may not be accessible.');
+        if (errors.length > 0)
+            header.push(`Failed keys: ${errors.join(', ')}`);
+        return { content: [{ type: 'text', text: header.join('\n') }] };
+    }
+    // Render each tree's rollup as a summary line
+    header.push(`## Issue Rollups (${allTrees.length} of ${issueKeys.length} resolved)`);
+    if (errors.length > 0) {
+        header.push(`*${errors.length} issues could not be walked: ${errors.join(', ')}*`);
+    }
+    header.push('');
+    let totalResolved = 0;
+    let totalItems = 0;
+    let totalPoints = 0;
+    let earnedPoints = 0;
+    for (const tree of allTrees) {
+        const rollup = GraphQLHierarchyWalker.computeRollups(tree);
+        totalResolved += rollup.resolvedItems;
+        totalItems += rollup.totalItems;
+        totalPoints += rollup.totalPoints;
+        earnedPoints += rollup.earnedPoints;
+        renderNodeLine(tree, header, rollups);
+    }
+    header.push('');
+    header.push('## Aggregate');
+    if (rollups.includes('progress')) {
+        const pct = totalItems > 0 ? Math.round(totalResolved / totalItems * 100) : 0;
+        header.push(`**Progress:** ${totalResolved}/${totalItems} resolved (${pct}%)`);
+    }
+    if (rollups.includes('points') && totalPoints > 0) {
+        header.push(`**Points:** ${earnedPoints}/${totalPoints} earned`);
+    }
+    header.push('');
+    header.push(goalNextSteps('analyze', goalKey, issueKeys.length));
+    return { content: [{ type: 'text', text: header.join('\n') }] };
+}
+function goalStateIcon(state) {
+    switch (state) {
+        case 'done': return '✓';
+        case 'on_track': return '●';
+        case 'at_risk': return '⚠';
+        case 'off_track': return '✗';
+        default: return '○';
+    }
+}
+// --- Goal mutations ---
+async function handleCreateGoal(graphqlClient, args) {
+    const name = args.name;
+    if (!name)
+        throw new McpError(ErrorCode.InvalidParams, 'name is required for create_goal');
+    const result = await createGoal(graphqlClient, {
+        name,
+        description: args.description,
+        parentGoalKey: args.parentGoalKey,
+        targetDate: args.targetDate,
+    });
+    if (!result.success || !result.goal) {
+        return { content: [{ type: 'text', text: `Failed to create goal: ${result.error}` }], isError: true };
+    }
+    const goal = result.goal;
+    const lines = [
+        `Goal created: **${goal.key}** — ${goal.name}`,
+        `URL: ${goal.url}`,
+        '',
+        goalNextSteps('create_goal', goal.key),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleUpdateGoal(graphqlClient, goalKey, args) {
+    const result = await editGoal(graphqlClient, goalKey, {
+        name: args.name,
+        description: args.description,
+        targetDate: args.targetDate,
+        startDate: args.startDate,
+        archived: args.archived,
+    });
+    if (!result.success) {
+        return { content: [{ type: 'text', text: `Failed to update goal ${goalKey}: ${result.error}` }], isError: true };
+    }
+    const lines = [
+        `Goal ${goalKey} updated.`,
+        '',
+        goalNextSteps('update_goal', goalKey),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleUpdateGoalStatus(graphqlClient, goalKey, args) {
+    const status = args.status;
+    if (!status)
+        throw new McpError(ErrorCode.InvalidParams, 'status is required for update_goal_status');
+    const result = await createGoalStatusUpdate(graphqlClient, goalKey, status, args.summary);
+    if (!result.success) {
+        return { content: [{ type: 'text', text: `Failed to update status for ${goalKey}: ${result.error}` }], isError: true };
+    }
+    const lines = [
+        `Goal ${goalKey} status updated to **${status}**.`,
+        args.summary ? `Summary: ${args.summary}` : '',
+        '',
+        goalNextSteps('update_goal_status', goalKey),
+    ].filter(Boolean);
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleLinkWorkItem(graphqlClient, goalKey, issueKey) {
+    const result = await linkWorkItem(graphqlClient, goalKey, issueKey);
+    if (!result.success) {
+        return { content: [{ type: 'text', text: `Failed to link ${issueKey} to goal ${goalKey}: ${result.error}` }], isError: true };
+    }
+    const lines = [
+        `Linked **${issueKey}** to goal **${goalKey}**.`,
+        '',
+        goalNextSteps('link_work_item', goalKey),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+async function handleUnlinkWorkItem(graphqlClient, goalKey, issueKey) {
+    const result = await unlinkWorkItem(graphqlClient, goalKey, issueKey);
+    if (!result.success) {
+        return { content: [{ type: 'text', text: `Failed to unlink ${issueKey} from goal ${goalKey}: ${result.error}` }], isError: true };
+    }
+    const lines = [
+        `Unlinked **${issueKey}** from goal **${goalKey}**.`,
+        '',
+        goalNextSteps('unlink_work_item', goalKey),
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}

package/build/handlers/resource-handlers.js

@@ -2,12 +2,14 @@ import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { setupToolResourceHandlers } from './tool-resource-handlers.js';
 import { fieldDiscovery } from '../client/field-discovery.js';
 import { categoryLabel } from '../client/field-type-map.js';
+import { searchGoals } from '../client/graphql-goals.js';
 /**
  * Sets up resource handlers for the Jira MCP server
  * @param jiraClient The Jira client instance
+ * @param graphqlClient Optional GraphQL client for Townsquare goals
  * @returns Object containing resource handlers
  */
-export function setupResourceHandlers(jiraClient) {
+export function setupResourceHandlers(jiraClient, graphqlClient) {
     const toolResourceHandler = setupToolResourceHandlers();
     return {
         /**
@@ -87,7 +89,7 @@ export function setupResourceHandlers(jiraClient) {
             try {
                 // Handle static resources
                 if (uri === 'jira://instance/summary') {
-                    return await getInstanceSummary(jiraClient);
+                    return await getInstanceSummary(jiraClient, graphqlClient);
                 }
                 if (uri === 'jira://projects/distribution') {
                     return await getProjectDistribution(jiraClient);
@@ -139,7 +141,7 @@ export function setupResourceHandlers(jiraClient) {
 /**
  * Gets a summary of the Jira instance
  */
-async function getInstanceSummary(jiraClient) {
+async function getInstanceSummary(jiraClient, graphqlClient) {
     try {
         // Get projects
         const projects = await jiraClient.listProjects();
@@ -157,6 +159,29 @@ async function getInstanceSummary(jiraClient) {
                 timestamp: new Date().toISOString()
             }
         };
+        // Fetch goal summary counts if GraphQL client is available
+        if (graphqlClient) {
+            try {
+                const result = await searchGoals(graphqlClient, '', 'HIERARCHY_ASC', 200);
+                if (result.success && result.goals && result.goals.length > 0) {
+                    const goals = result.goals;
+                    const stateCounts = {};
+                    for (const g of goals) {
+                        stateCounts[g.state.value] = (stateCounts[g.state.value] ?? 0) + 1;
+                    }
+                    const themes = goals.filter(g => !g.parentGoal).length;
+                    summary.goals = {
+                        total: goals.length,
+                        themes,
+                        ...stateCounts,
+                        hint: 'Use manage_jira_plan with operation list_goals to explore the goal tree',
+                    };
+                }
+            }
+            catch {
+                // Goals not available on this instance — skip silently
+            }
+        }
         return {
             contents: [
                 {

package/build/handlers/workspace-handler.js

@@ -0,0 +1,214 @@
+/**
+ * Handler for manage_workspace tool.
+ * See ADR-211: Attachment and Workspace Management.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { ensureWorkspaceDir, formatSize, resolveWorkspacePath, ensureParentDir, verifyPathSafety, } from '../workspace/index.js';
+const TEXT_INLINE_LIMIT = 100 * 1024; // 100KB
+const IMAGE_INLINE_LIMIT = 5 * 1024 * 1024; // 5MB
+const IMAGE_EXTENSIONS = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.bmp': 'image/bmp',
+    '.ico': 'image/x-icon',
+};
+const TEXT_EXTENSIONS = new Set([
+    '.txt', '.md', '.json', '.xml', '.csv', '.html', '.htm',
+    '.yaml', '.yml', '.toml', '.ini', '.cfg', '.conf', '.log',
+    '.js', '.ts', '.py', '.rb', '.sh', '.bash', '.zsh',
+    '.css', '.scss', '.less', '.svg',
+]);
+export async function handleWorkspaceRequest(args) {
+    switch (args.operation) {
+        case 'list':
+            return handleList();
+        case 'read':
+            return handleRead(args);
+        case 'write':
+            return handleWrite(args);
+        case 'delete':
+            return handleDelete(args);
+        case 'mkdir':
+            return handleMkdir(args);
+        case 'move':
+            return handleMove(args);
+        default:
+            return { content: [{ type: 'text', text: `Unknown workspace operation: ${args.operation}` }], isError: true };
+    }
+}
+async function handleList() {
+    const status = await ensureWorkspaceDir();
+    if (!status.valid) {
+        return { content: [{ type: 'text', text: `Workspace invalid: ${status.warning}` }], isError: true };
+    }
+    const lines = [`Workspace: ${status.path}\n`];
+    await listRecursive(status.path, status.path, lines, 0);
+    if (lines.length === 1) {
+        return { content: [{ type: 'text', text: `Workspace: ${status.path}\n\n(empty — no files staged)` }] };
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+const MAX_LIST_DEPTH = 10;
+async function listRecursive(rootDir, dir, lines, depth) {
+    if (depth >= MAX_LIST_DEPTH) {
+        lines.push(`${'  '.repeat(depth + 1)}(truncated — max depth ${MAX_LIST_DEPTH})`);
+        return;
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const indent = '  '.repeat(depth + 1);
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (entry.isSymbolicLink())
+            continue; // skip symlinks to prevent loops
+        try {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                lines.push(`${indent}${entry.name}/`);
+                await listRecursive(rootDir, fullPath, lines, depth + 1);
+            }
+            else if (entry.isFile()) {
+                const stat = await fs.stat(fullPath);
+                lines.push(`${indent}${entry.name}  (${formatSize(stat.size)}, ${stat.mtime.toISOString().slice(0, 16)})`);
+            }
+        }
+        catch {
+            // Skip entries we can't stat
+        }
+    }
+}
+async function handleRead(args) {
+    if (!args.filename) {
+        return { content: [{ type: 'text', text: 'filename is required for read operation' }], isError: true };
+    }
+    const filePath = resolveWorkspacePath(args.filename);
+    await verifyPathSafety(filePath);
+    let stat;
+    try {
+        stat = await fs.stat(filePath);
+    }
+    catch {
+        return { content: [{ type: 'text', text: `File not found in workspace: ${args.filename}` }], isError: true };
+    }
+    const ext = path.extname(args.filename).toLowerCase();
+    const isText = TEXT_EXTENSIONS.has(ext);
+    const imageMime = IMAGE_EXTENSIONS[ext];
+    // Inline text
+    if (isText && stat.size <= TEXT_INLINE_LIMIT) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return { content: [{ type: 'text', text: `File: ${args.filename} (${formatSize(stat.size)})\nPath: ${filePath}\n\n${content}` }] };
+    }
+    // Inline image
+    if (imageMime && stat.size <= IMAGE_INLINE_LIMIT) {
+        const bytes = await fs.readFile(filePath);
+        return {
+            content: [
+                { type: 'text', text: `File: ${args.filename} | ${formatSize(stat.size)}\nPath: ${filePath}` },
+                { type: 'image', data: bytes.toString('base64'), mimeType: imageMime },
+            ],
+        };
+    }
+    // Too large or unsupported — path reference only
+    const label = imageMime ? 'image (too large to display inline)' : isText ? 'text' : 'binary';
+    return {
+        content: [{
+                type: 'text',
+                text: `File: ${args.filename} | ${formatSize(stat.size)} | ${label}\nPath: ${filePath}\n\nUse manage_jira_media upload with workspaceFile to upload, or manage_workspace delete to remove.`,
+            }],
+    };
+}
+async function handleWrite(args) {
+    if (!args.filename) {
+        return { content: [{ type: 'text', text: 'filename is required for write operation' }], isError: true };
+    }
+    if (!args.content) {
+        return { content: [{ type: 'text', text: 'content (base64-encoded) is required for write operation' }], isError: true };
+    }
+    const status = await ensureWorkspaceDir();
+    if (!status.valid) {
+        return { content: [{ type: 'text', text: `Workspace invalid: ${status.warning}` }], isError: true };
+    }
+    const filePath = resolveWorkspacePath(args.filename);
+    await verifyPathSafety(filePath);
+    await ensureParentDir(filePath);
+    const buffer = Buffer.from(args.content, 'base64');
+    await fs.writeFile(filePath, buffer);
+    return {
+        content: [{
+                type: 'text',
+                text: `Written: ${args.filename} (${formatSize(buffer.length)})\nPath: ${filePath}`,
+            }],
+    };
+}
+async function handleDelete(args) {
+    if (!args.filename) {
+        return { content: [{ type: 'text', text: 'filename is required for delete operation' }], isError: true };
+    }
+    const filePath = resolveWorkspacePath(args.filename);
+    await verifyPathSafety(filePath);
+    try {
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            await fs.rm(filePath, { recursive: true });
+            return { content: [{ type: 'text', text: `Deleted local directory: ${args.filename} (Jira attachments unaffected)` }] };
+        }
+        await fs.unlink(filePath);
+    }
+    catch {
+        return { content: [{ type: 'text', text: `File not found in workspace: ${args.filename}` }], isError: true };
+    }
+    return { content: [{ type: 'text', text: `Deleted local file: ${args.filename} (Jira attachments unaffected)` }] };
+}
+async function handleMkdir(args) {
+    if (!args.filename) {
+        return { content: [{ type: 'text', text: 'filename (directory path) is required for mkdir operation' }], isError: true };
+    }
+    const status = await ensureWorkspaceDir();
+    if (!status.valid) {
+        return { content: [{ type: 'text', text: `Workspace invalid: ${status.warning}` }], isError: true };
+    }
+    const dirPath = resolveWorkspacePath(args.filename);
+    await verifyPathSafety(dirPath);
+    await fs.mkdir(dirPath, { recursive: true, mode: 0o755 });
+    return {
+        content: [{
+                type: 'text',
+                text: `Created: ${args.filename}/\nPath: ${dirPath}`,
+            }],
+    };
+}
+async function handleMove(args) {
+    if (!args.filename) {
+        return { content: [{ type: 'text', text: 'filename (source path) is required for move operation' }], isError: true };
+    }
+    if (!args.destination) {
+        return { content: [{ type: 'text', text: 'destination path is required for move operation' }], isError: true };
+    }
+    const srcPath = resolveWorkspacePath(args.filename);
+    await verifyPathSafety(srcPath);
+    const destPath = resolveWorkspacePath(args.destination);
+    await verifyPathSafety(destPath);
+    try {
+        await fs.stat(srcPath);
+    }
+    catch {
+        return { content: [{ type: 'text', text: `Source not found in workspace: ${args.filename}` }], isError: true };
+    }
+    await ensureParentDir(destPath);
+    await fs.rename(srcPath, destPath);
+    return {
+        content: [{
+                type: 'text',
+                text: `Moved: ${args.filename} -> ${args.destination}\nPath: ${destPath}`,
+            }],
+    };
+}