gmc-openspec 1.0.0

package/dist/core/jira/config.js

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync } from 'fs';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { z } from 'zod';
+import { AI_TOOLS } from '../config.js';
+import { JIRA_CONFIG_VERSION, JIRA_DEFAULT_ENDPOINT, JIRA_DEFAULT_PROVIDER, } from './constants.js';
+import { getJiraConfigPath } from './paths.js';
+export const JiraConfigSchema = z
+    .object({
+    version: z.number().int().positive().default(JIRA_CONFIG_VERSION),
+    provider: z.literal(JIRA_DEFAULT_PROVIDER).default(JIRA_DEFAULT_PROVIDER),
+    endpoint: z.string().url().default(JIRA_DEFAULT_ENDPOINT),
+    tools: z.array(z.string()).default([]),
+    issueTypes: z
+        .object({
+        epic: z.array(z.string()).default(['Epic']),
+        feature: z.array(z.string()).default(['Feature', 'Story']),
+    })
+        .default({ epic: ['Epic'], feature: ['Feature', 'Story'] }),
+    fields: z
+        .object({
+        summary: z.string().default('summary'),
+        description: z.string().default('description'),
+        acceptanceCriteria: z.string().default('customfield_*'),
+    })
+        .default({
+        summary: 'summary',
+        description: 'description',
+        acceptanceCriteria: 'customfield_*',
+    }),
+    writeback: z
+        .object({
+        enabled: z.boolean().default(false),
+        requireConfirmation: z.boolean().default(true),
+    })
+        .default({ enabled: false, requireConfirmation: true }),
+})
+    .passthrough();
+export function createDefaultJiraConfig(tools = []) {
+    return JiraConfigSchema.parse({ tools });
+}
+export function readJiraConfig(projectRoot) {
+    const configPath = getJiraConfigPath(projectRoot);
+    const warnings = [];
+    if (!existsSync(configPath)) {
+        return { config: null, path: configPath, warnings };
+    }
+    try {
+        const rawContent = readFileSync(configPath, 'utf8');
+        const raw = parseYaml(rawContent);
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+            warnings.push('openspec/jira.yaml must be a YAML object');
+            return { config: null, path: configPath, warnings };
+        }
+        const parsed = JiraConfigSchema.safeParse(raw);
+        if (!parsed.success) {
+            warnings.push(...parsed.error.issues.map((issue) => `${issue.path.join('.') || 'config'}: ${issue.message}`));
+            return { config: null, path: configPath, warnings };
+        }
+        warnings.push(...getJiraConfigWarnings(parsed.data));
+        return { config: parsed.data, path: configPath, warnings };
+    }
+    catch (error) {
+        warnings.push(`Failed to parse openspec/jira.yaml: ${error instanceof Error ? error.message : String(error)}`);
+        return { config: null, path: configPath, warnings };
+    }
+}
+export function getJiraConfigWarnings(config) {
+    const warnings = [];
+    if (config.endpoint.includes('/v1/sse')) {
+        warnings.push('Atlassian Rovo MCP /v1/sse endpoint is deprecated; use https://mcp.atlassian.com/v1/mcp/authv2.');
+    }
+    else if (config.endpoint === 'https://mcp.atlassian.com/v1/mcp') {
+        warnings.push('Atlassian Rovo MCP /v1/mcp endpoint is outdated; use https://mcp.atlassian.com/v1/mcp/authv2.');
+    }
+    const validToolIds = new Set(AI_TOOLS.filter((tool) => tool.skillsDir).map((tool) => tool.value));
+    for (const tool of config.tools) {
+        if (!validToolIds.has(tool)) {
+            warnings.push(`Unknown or unsupported AI tool in jira.yaml: ${tool}`);
+        }
+    }
+    if (containsSecretLikeKey(config)) {
+        warnings.push('openspec/jira.yaml contains secret-like keys; setup will not preserve token, secret, password, or OAuth credential fields.');
+    }
+    return warnings;
+}
+export async function writeJiraConfig(projectRoot, config, options = {}) {
+    const configPath = getJiraConfigPath(projectRoot);
+    const existing = existsSync(configPath) ? parseExistingConfig(configPath) : {};
+    const merged = sanitizeSecretLikeKeys({ ...existing, ...config });
+    const parsed = JiraConfigSchema.parse(merged);
+    if (existsSync(configPath) && !options.force) {
+        const existingContent = readFileSync(configPath, 'utf8');
+        const nextContent = serializeJiraConfig(parsed);
+        if (existingContent.trim() === nextContent.trim()) {
+            return configPath;
+        }
+    }
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, serializeJiraConfig(parsed), 'utf8');
+    return configPath;
+}
+export function serializeJiraConfig(config) {
+    return stringifyYaml(sanitizeSecretLikeKeys(config), { lineWidth: 0 });
+}
+function parseExistingConfig(configPath) {
+    try {
+        const raw = parseYaml(readFileSync(configPath, 'utf8'));
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+            return raw;
+        }
+    }
+    catch {
+        // Ignore invalid existing config during setup; schema parsing will rewrite a safe file.
+    }
+    return {};
+}
+function isSecretLikeKey(key) {
+    return /(token|secret|password|clientsecret|apikey|api_key|oauth)/i.test(key);
+}
+export function sanitizeSecretLikeKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeSecretLikeKeys(item));
+    }
+    if (value && typeof value === 'object') {
+        const output = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (isSecretLikeKey(key))
+                continue;
+            output[key] = sanitizeSecretLikeKeys(child);
+        }
+        return output;
+    }
+    return value;
+}
+function containsSecretLikeKey(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => containsSecretLikeKey(item));
+    }
+    if (value && typeof value === 'object') {
+        for (const [key, child] of Object.entries(value)) {
+            if (isSecretLikeKey(key))
+                return true;
+            if (containsSecretLikeKey(child))
+                return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=config.js.map

package/dist/core/jira/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const JIRA_DIR_NAME = "jira";
+export declare const JIRA_CONFIG_FILE = "jira.yaml";
+export declare const JIRA_CONFIG_VERSION = 1;
+export declare const JIRA_INTAKE_SCHEMA_VERSION = 1;
+export declare const JIRA_DEFAULT_PROVIDER = "atlassian-rovo";
+export declare const JIRA_DEFAULT_ENDPOINT = "https://mcp.atlassian.com/v1/mcp/authv2";
+export declare const JIRA_WORKFLOW_IDS: readonly ["jira-import", "jira-refine", "jira-review", "jira-split", "jira-propose", "jira-sync"];
+export type JiraWorkflowId = (typeof JIRA_WORKFLOW_IDS)[number];
+export declare const JIRA_WORKFLOW_TO_SKILL_DIR: Record<JiraWorkflowId, string>;
+export declare const JIRA_STATUS_ORDER: readonly ["imported", "refining", "ready-for-review", "reviewed", "split", "stories-reviewed", "proposed", "synced"];
+export type JiraIntakeStatus = (typeof JIRA_STATUS_ORDER)[number];
+export declare const JIRA_ALLOWED_NEXT: Record<JiraIntakeStatus, JiraIntakeStatus[]>;
+export declare const JIRA_STAGE_MIN_STATUS: {
+    readonly source: "imported";
+    readonly requirement: "ready-for-review";
+    readonly stories: "stories-reviewed";
+    readonly propose: "proposed";
+};
+export type JiraValidationStage = keyof typeof JIRA_STAGE_MIN_STATUS;
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/jira/constants.js

@@ -0,0 +1,49 @@
+export const JIRA_DIR_NAME = 'jira';
+export const JIRA_CONFIG_FILE = 'jira.yaml';
+export const JIRA_CONFIG_VERSION = 1;
+export const JIRA_INTAKE_SCHEMA_VERSION = 1;
+export const JIRA_DEFAULT_PROVIDER = 'atlassian-rovo';
+export const JIRA_DEFAULT_ENDPOINT = 'https://mcp.atlassian.com/v1/mcp/authv2';
+export const JIRA_WORKFLOW_IDS = [
+    'jira-import',
+    'jira-refine',
+    'jira-review',
+    'jira-split',
+    'jira-propose',
+    'jira-sync',
+];
+export const JIRA_WORKFLOW_TO_SKILL_DIR = {
+    'jira-import': 'openspec-jira-import',
+    'jira-refine': 'openspec-jira-refine',
+    'jira-review': 'openspec-jira-review',
+    'jira-split': 'openspec-jira-split',
+    'jira-propose': 'openspec-jira-propose',
+    'jira-sync': 'openspec-jira-sync',
+};
+export const JIRA_STATUS_ORDER = [
+    'imported',
+    'refining',
+    'ready-for-review',
+    'reviewed',
+    'split',
+    'stories-reviewed',
+    'proposed',
+    'synced',
+];
+export const JIRA_ALLOWED_NEXT = {
+    imported: ['refining'],
+    refining: ['ready-for-review'],
+    'ready-for-review': ['reviewed'],
+    reviewed: ['split'],
+    split: ['stories-reviewed'],
+    'stories-reviewed': ['proposed'],
+    proposed: ['synced'],
+    synced: [],
+};
+export const JIRA_STAGE_MIN_STATUS = {
+    source: 'imported',
+    requirement: 'ready-for-review',
+    stories: 'stories-reviewed',
+    propose: 'proposed',
+};
+//# sourceMappingURL=constants.js.map

package/dist/core/jira/doctor.d.ts

@@ -0,0 +1,19 @@
+import { type JiraMcpConfigResult } from './mcp-config.js';
+export type JiraDoctorLevel = 'ok' | 'warning' | 'error' | 'manual-action-required';
+export interface JiraDoctorCheck {
+    id: string;
+    level: JiraDoctorLevel;
+    message: string;
+    details?: string;
+}
+export interface JiraDoctorReport {
+    ok: boolean;
+    configPath: string;
+    checks: JiraDoctorCheck[];
+    tools: string[];
+    mcpConfigs: JiraMcpConfigResult[];
+    testPrompt: string;
+    mcpSnippet?: string;
+}
+export declare function runJiraDoctor(projectRoot: string): JiraDoctorReport;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/core/jira/doctor.js

@@ -0,0 +1,173 @@
+import { existsSync } from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { AI_TOOLS } from '../config.js';
+import { getAvailableTools } from '../available-tools.js';
+import { CommandAdapterRegistry } from '../command-generation/index.js';
+import { readJiraConfig } from './config.js';
+import { JIRA_WORKFLOW_IDS, JIRA_WORKFLOW_TO_SKILL_DIR } from './constants.js';
+import { inspectJiraMcpConfig } from './mcp-config.js';
+import { getMcpSnippet } from './setup.js';
+import { toDisplayPath } from './paths.js';
+export function runJiraDoctor(projectRoot) {
+    const checks = [];
+    const { config, path: configPath, warnings } = readJiraConfig(projectRoot);
+    if (!config) {
+        checks.push({
+            id: 'jira-config',
+            level: 'error',
+            message: 'Missing or invalid openspec/jira.yaml.',
+            details: warnings.join('\n') || 'Run openspec jira setup first.',
+        });
+        return finish(configPath, checks, [], [], undefined);
+    }
+    checks.push({ id: 'jira-config', level: 'ok', message: 'Found openspec/jira.yaml.' });
+    for (const warning of warnings) {
+        checks.push({ id: 'jira-config-warning', level: 'warning', message: warning });
+    }
+    checks.push(checkNodeVersion());
+    checks.push(checkNpx());
+    if (config.endpoint.includes('/v1/sse')) {
+        checks.push({
+            id: 'mcp-endpoint',
+            level: 'warning',
+            message: 'Configured endpoint uses deprecated /v1/sse. Use https://mcp.atlassian.com/v1/mcp/authv2.',
+        });
+    }
+    else if (config.endpoint === 'https://mcp.atlassian.com/v1/mcp') {
+        checks.push({
+            id: 'mcp-endpoint',
+            level: 'warning',
+            message: 'Configured endpoint uses outdated /v1/mcp. Use https://mcp.atlassian.com/v1/mcp/authv2.',
+        });
+    }
+    else {
+        checks.push({ id: 'mcp-endpoint', level: 'ok', message: `MCP endpoint: ${config.endpoint}` });
+    }
+    const detected = new Set(getAvailableTools(projectRoot).map((tool) => tool.value));
+    if (detected.size === 0) {
+        checks.push({ id: 'detected-tools', level: 'warning', message: 'No AI tool directories detected in this project.' });
+    }
+    else {
+        checks.push({ id: 'detected-tools', level: 'ok', message: `Detected tools: ${[...detected].join(', ')}` });
+    }
+    for (const toolId of config.tools) {
+        checks.push(checkToolInstall(projectRoot, toolId));
+    }
+    const mcpConfigs = config.tools.map((toolId) => inspectJiraMcpConfig(projectRoot, toolId, config.endpoint));
+    for (const mcpConfig of mcpConfigs) {
+        checks.push(checkMcpConfig(mcpConfig));
+    }
+    checks.push({
+        id: 'jira-auth',
+        level: 'manual-action-required',
+        message: 'OAuth and Jira permissions must be verified inside your AI client.',
+        details: `Use the test prompt after restarting your AI client. MCP snippet:\n${getMcpSnippet(config.endpoint)}`,
+    });
+    return finish(configPath, checks, config.tools, mcpConfigs, getMcpSnippet(config.endpoint));
+}
+function finish(configPath, checks, tools, mcpConfigs, mcpSnippet) {
+    return {
+        ok: checks.every((check) => check.level !== 'error'),
+        configPath,
+        checks,
+        tools,
+        mcpConfigs,
+        mcpSnippet,
+        testPrompt: 'Use the Jira MCP server to read a harmless issue by id, then summarize summary, status, description, and acceptance criteria without writing to Jira.',
+    };
+}
+function checkMcpConfig(result) {
+    if (result.status === 'already-present') {
+        return { id: `mcp-${result.toolId}`, level: 'ok', message: result.message };
+    }
+    if (result.status === 'created') {
+        return {
+            id: `mcp-${result.toolId}`,
+            level: 'manual-action-required',
+            message: `Missing official Atlassian MCP config for ${result.toolId}. Run openspec jira setup --tools ${result.toolId} --force.`,
+            details: result.path,
+        };
+    }
+    if (result.status === 'updated') {
+        return {
+            id: `mcp-${result.toolId}`,
+            level: 'warning',
+            message: `Official Atlassian MCP config for ${result.toolId} needs refresh. Run openspec jira setup --tools ${result.toolId} --force.`,
+            details: result.message,
+        };
+    }
+    if (result.status === 'invalid-json') {
+        return {
+            id: `mcp-${result.toolId}`,
+            level: 'manual-action-required',
+            message: `Cannot inspect Atlassian MCP config for ${result.toolId}.`,
+            details: result.message,
+        };
+    }
+    return {
+        id: `mcp-${result.toolId}`,
+        level: 'manual-action-required',
+        message: `OpenSpec cannot auto-write official Atlassian MCP config for ${result.toolId}.`,
+        details: result.message,
+    };
+}
+function checkNodeVersion() {
+    const major = Number(process.versions.node.split('.')[0]);
+    if (Number.isFinite(major) && major >= 18) {
+        return { id: 'node-version', level: 'ok', message: `Node.js ${process.versions.node} is compatible with mcp-remote.` };
+    }
+    return {
+        id: 'node-version',
+        level: 'error',
+        message: `Node.js ${process.versions.node} is too old for mcp-remote; use Node.js 18 or newer.`,
+    };
+}
+function checkNpx() {
+    const result = spawnSync('npx', ['--version'], {
+        encoding: 'utf8',
+        shell: process.platform === 'win32',
+    });
+    if (result.status === 0) {
+        return { id: 'npx', level: 'ok', message: `npx is available (${result.stdout.trim()}).` };
+    }
+    return {
+        id: 'npx',
+        level: 'warning',
+        message: 'npx was not found; MCP clients using mcp-remote may fail until Node/npm tooling is installed.',
+        details: result.stderr?.trim(),
+    };
+}
+function checkToolInstall(projectRoot, toolId) {
+    const tool = AI_TOOLS.find((candidate) => candidate.value === toolId);
+    if (!tool?.skillsDir) {
+        return { id: `tool-${toolId}`, level: 'warning', message: `Unknown or unsupported configured tool: ${toolId}` };
+    }
+    const missing = [];
+    for (const workflowId of JIRA_WORKFLOW_IDS) {
+        const skillPath = path.join(projectRoot, tool.skillsDir, 'skills', JIRA_WORKFLOW_TO_SKILL_DIR[workflowId], 'SKILL.md');
+        if (!existsSync(skillPath)) {
+            missing.push(toDisplayPath(projectRoot, skillPath));
+        }
+    }
+    const adapter = CommandAdapterRegistry.get(toolId);
+    if (adapter) {
+        for (const workflowId of JIRA_WORKFLOW_IDS) {
+            const commandPath = adapter.getFilePath(workflowId);
+            const fullPath = path.isAbsolute(commandPath) ? commandPath : path.join(projectRoot, commandPath);
+            if (!existsSync(fullPath)) {
+                missing.push(path.isAbsolute(fullPath) ? fullPath : toDisplayPath(projectRoot, fullPath));
+            }
+        }
+    }
+    if (missing.length === 0) {
+        return { id: `tool-${toolId}`, level: 'ok', message: `Jira intake artifacts installed for ${tool.name}.` };
+    }
+    return {
+        id: `tool-${toolId}`,
+        level: 'manual-action-required',
+        message: `Jira intake artifacts are incomplete for ${tool.name}. Run openspec jira setup --tools ${toolId} --force.`,
+        details: missing.slice(0, 8).join('\n'),
+    };
+}
+//# sourceMappingURL=doctor.js.map

package/dist/core/jira/hash.d.ts

@@ -0,0 +1,3 @@
+export declare function hashContentSha256(content: string): string;
+export declare function hashFileSha256(filePath: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/core/jira/hash.js

@@ -0,0 +1,9 @@
+import { createHash } from 'crypto';
+import { readFileSync } from 'fs';
+export function hashContentSha256(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+export function hashFileSha256(filePath) {
+    return hashContentSha256(readFileSync(filePath, 'utf8'));
+}
+//# sourceMappingURL=hash.js.map

package/dist/core/jira/index.d.ts

@@ -0,0 +1,11 @@
+export * from './config.js';
+export * from './constants.js';
+export * from './doctor.js';
+export * from './hash.js';
+export * from './intake.js';
+export * from './mcp-config.js';
+export * from './paths.js';
+export * from './setup.js';
+export * from './templates.js';
+export * from './validation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/jira/index.js

@@ -0,0 +1,11 @@
+export * from './config.js';
+export * from './constants.js';
+export * from './doctor.js';
+export * from './hash.js';
+export * from './intake.js';
+export * from './mcp-config.js';
+export * from './paths.js';
+export * from './setup.js';
+export * from './templates.js';
+export * from './validation.js';
+//# sourceMappingURL=index.js.map

package/dist/core/jira/intake.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { type JiraIntakeStatus } from './constants.js';
+export declare const JiraIntakeSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodNumber>;
+    jira: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        split: "split";
+        imported: "imported";
+        refining: "refining";
+        "ready-for-review": "ready-for-review";
+        reviewed: "reviewed";
+        "stories-reviewed": "stories-reviewed";
+        proposed: "proposed";
+        synced: "synced";
+    }>>;
+    sourceHashSha256: z.ZodOptional<z.ZodString>;
+    allowedNext: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        split: "split";
+        imported: "imported";
+        refining: "refining";
+        "ready-for-review": "ready-for-review";
+        reviewed: "reviewed";
+        "stories-reviewed": "stories-reviewed";
+        proposed: "proposed";
+        synced: "synced";
+    }>>>;
+}, z.core.$loose>;
+export type JiraIntake = z.infer<typeof JiraIntakeSchema>;
+export interface ReadJiraIntakeResult {
+    intake: JiraIntake | null;
+    issueDir: string;
+    path: string;
+    warnings: string[];
+}
+export declare function readJiraIntake(projectRoot: string, jiraId: string): ReadJiraIntakeResult;
+export declare function getAllowedNext(status: JiraIntakeStatus): JiraIntakeStatus[];
+export declare function canTransition(from: JiraIntakeStatus, to: JiraIntakeStatus): boolean;
+export declare function compareStatus(a: JiraIntakeStatus, b: JiraIntakeStatus): number;
+export declare function statusAtLeast(current: JiraIntakeStatus, required: JiraIntakeStatus): boolean;
+//# sourceMappingURL=intake.d.ts.map

package/dist/core/jira/intake.js

@@ -0,0 +1,54 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { parse as parseYaml } from 'yaml';
+import { z } from 'zod';
+import { JIRA_ALLOWED_NEXT, JIRA_INTAKE_SCHEMA_VERSION, JIRA_STATUS_ORDER, } from './constants.js';
+import { getJiraIssueDir, normalizeJiraId } from './paths.js';
+export const JiraIntakeSchema = z
+    .object({
+    schemaVersion: z.number().int().positive().default(JIRA_INTAKE_SCHEMA_VERSION),
+    jira: z.string().min(1),
+    status: z.enum(JIRA_STATUS_ORDER).default('imported'),
+    sourceHashSha256: z.string().optional(),
+    allowedNext: z.array(z.enum(JIRA_STATUS_ORDER)).optional(),
+})
+    .passthrough();
+export function readJiraIntake(projectRoot, jiraId) {
+    const issueDir = getJiraIssueDir(projectRoot, jiraId);
+    const intakePath = path.join(issueDir, 'intake.yaml');
+    const warnings = [];
+    if (!existsSync(intakePath)) {
+        return { intake: null, issueDir, path: intakePath, warnings };
+    }
+    try {
+        const raw = parseYaml(readFileSync(intakePath, 'utf8'));
+        const parsed = JiraIntakeSchema.safeParse(raw);
+        if (!parsed.success) {
+            warnings.push(...parsed.error.issues.map((issue) => `${issue.path.join('.') || 'intake'}: ${issue.message}`));
+            return { intake: null, issueDir, path: intakePath, warnings };
+        }
+        const expected = normalizeJiraId(jiraId);
+        const actual = normalizeJiraId(parsed.data.jira);
+        if (actual !== expected) {
+            warnings.push(`intake.yaml jira field is ${actual}, expected ${expected}`);
+        }
+        return { intake: parsed.data, issueDir, path: intakePath, warnings };
+    }
+    catch (error) {
+        warnings.push(`Failed to parse intake.yaml: ${error instanceof Error ? error.message : String(error)}`);
+        return { intake: null, issueDir, path: intakePath, warnings };
+    }
+}
+export function getAllowedNext(status) {
+    return JIRA_ALLOWED_NEXT[status];
+}
+export function canTransition(from, to) {
+    return JIRA_ALLOWED_NEXT[from].includes(to);
+}
+export function compareStatus(a, b) {
+    return JIRA_STATUS_ORDER.indexOf(a) - JIRA_STATUS_ORDER.indexOf(b);
+}
+export function statusAtLeast(current, required) {
+    return compareStatus(current, required) >= 0;
+}
+//# sourceMappingURL=intake.js.map

package/dist/core/jira/mcp-config.d.ts

@@ -0,0 +1,13 @@
+export type JiraMcpConfigStatus = 'created' | 'updated' | 'already-present' | 'unsupported' | 'invalid-json';
+export interface JiraMcpConfigResult {
+    toolId: string;
+    status: JiraMcpConfigStatus;
+    path?: string;
+    serverName?: string;
+    message: string;
+}
+export declare function ensureJiraMcpConfigs(projectRoot: string, toolIds: string[], endpoint: string): Promise<JiraMcpConfigResult[]>;
+export declare function ensureJiraMcpConfig(projectRoot: string, toolId: string, endpoint: string): Promise<JiraMcpConfigResult>;
+export declare function inspectJiraMcpConfig(projectRoot: string, toolId: string, endpoint: string): JiraMcpConfigResult;
+export declare function getManualJiraMcpSetupHint(toolId: string, endpoint: string): string;
+//# sourceMappingURL=mcp-config.d.ts.map