@planu/cli 5.7.4 → 5.7.6

package/dist/tools/clarify-requirements/questions.js

@@ -1,96 +0,0 @@
-/** Returns true if the topic has fewer than 3 words (extremely vague — meta-questions needed). */
-export function isShortTopic(topic) {
-    return topic.trim().split(/\s+/).length < 3;
-}
-/** Generate meta-questions to scope a vague topic. */
-export function generateMetaQuestions() {
-    return [
-        {
-            id: 'meta-1',
-            question: 'Which change type best describes the request?',
-            category: 'scope',
-            importance: 'critical',
-            suggestedAnswers: ['New feature', 'Improvement to existing feature', 'Bug fix', 'Refactor'],
-        },
-        {
-            id: 'meta-2',
-            question: 'What observable outcome must this work produce?',
-            category: 'scope',
-            importance: 'critical',
-        },
-        {
-            id: 'meta-3',
-            question: 'Which boundaries are explicitly in scope and out of scope?',
-            category: 'scope',
-            importance: 'critical',
-        },
-    ];
-}
-/**
- * Detect contradictions in a set of answers.
- * Returns an array of human-readable contradiction descriptions.
- */
-export function detectContradictions(answers) {
-    const contradictions = [];
-    const values = Object.values(answers).map((v) => v.toLowerCase());
-    const joined = values.join(' ');
-    // Heuristic: "fast" / "no cache"
-    if ((joined.includes('fast') || joined.includes('performant') || joined.includes('low latency')) &&
-        (joined.includes('no cache') ||
-            joined.includes('without cache') ||
-            joined.includes('sin cache'))) {
-        contradictions.push('Performance requirement ("fast") may conflict with "no cache" — caching is a primary tool for low-latency responses.');
-    }
-    // Heuristic: "simple" / many features
-    const featureKeywords = [
-        'real-time',
-        'realtime',
-        'offline',
-        'multi-tenant',
-        'i18n',
-        'analytics',
-        'notifications',
-    ];
-    const wantsSimple = joined.includes('simple') || joined.includes('minimal') || joined.includes('lightweight');
-    const wantsComplex = featureKeywords.some((k) => joined.includes(k));
-    if (wantsSimple && wantsComplex) {
-        contradictions.push('Scope may be underestimated: "simple/minimal" combined with advanced features (real-time, offline, multi-tenant, etc.) typically results in a complex implementation.');
-    }
-    // Heuristic: deadline conflicts
-    if ((joined.includes('urgent') || joined.includes('asap') || joined.includes('tomorrow')) &&
-        (joined.includes('comprehensive') ||
-            joined.includes('complete') ||
-            joined.includes('all edge cases'))) {
-        contradictions.push('Timeline conflict: "urgent/ASAP" deadline with "comprehensive/all edge cases" scope — consider scoping down to an MVP first.');
-    }
-    return contradictions;
-}
-/**
- * Build suggested answers for a question using project knowledge.
- */
-export function buildSuggestedAnswers(question, knowledge) {
-    const lower = question.question.toLowerCase();
-    // Database-related: suggest the project's database
-    if (lower.includes('database') || lower.includes('table') || lower.includes('schema')) {
-        if (knowledge && knowledge.database !== 'unknown') {
-            return [
-                `Yes, using project's ${knowledge.database} database`,
-                'No new tables needed',
-                'Needs new tables',
-                'Modifies existing tables',
-            ];
-        }
-    }
-    // Framework-related: suggest the project's framework
-    if (lower.includes('framework') || lower.includes('pattern') || lower.includes('component')) {
-        if (knowledge?.framework) {
-            return [
-                `Yes, reuse ${knowledge.framework} patterns`,
-                'New pattern needed',
-                'Mix of existing and new',
-            ];
-        }
-    }
-    return [];
-}
-//# sourceMappingURL=questions.js.map

package/dist/tools/clarify-requirements.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ClarifyRequirementsInput, ToolResult } from '../types/index.js';
-export declare function handleClarifyRequirements(params: ClarifyRequirementsInput, server?: McpServer): Promise<ToolResult>;
-//# sourceMappingURL=clarify-requirements.d.ts.map

package/dist/tools/clarify-requirements.js

@@ -1,314 +0,0 @@
-import { elicitOrFallback, buildEnumSchema } from '../engine/elicitation/elicit-helper.js';
-import { ti } from '../i18n/index.js';
-import { knowledgeStore } from '../storage/index.js';
-import { randomUUID } from 'node:crypto';
-import { isShortTopic, generateMetaQuestions, detectContradictions, buildSuggestedAnswers, } from './clarify-requirements/questions.js';
-import { generateQuestions } from './clarify-requirements/questions-context.js';
-import { detectStack, shouldSkipQuestion, attachOptions, buildSuggestedDescription, } from './clarify-requirements/multiple-choice.js';
-import { compactJson, compactResult, compactError } from './output-formatter.js';
-function buildConfirmedChoices(questions, answers) {
-    return questions.flatMap((question) => {
-        const value = answers[question.id]?.trim();
-        return value ? [{ questionId: question.id, value, source: 'user_confirmation' }] : [];
-    });
-}
-/** Resume an existing clarification session with new answers. */
-async function handleResumeSession(projectId, sessionId, newAnswers, knowledge) {
-    const existing = await knowledgeStore.getClarification(projectId, sessionId).catch(() => null);
-    if (!existing) {
-        return compactError(`Session '${sessionId}' not found. Start a new session by calling clarify_requirements without sessionId.`);
-    }
-    const mergedAnswers = { ...existing.answers, ...newAnswers };
-    const contradictions = Object.keys(mergedAnswers).length > 0 ? detectContradictions(mergedAnswers) : [];
-    const criticalIds = existing.questions
-        .filter((q) => q.importance === 'critical')
-        .map((q) => q.id);
-    const specReady = criticalIds.every((id) => {
-        const ans = mergedAnswers[id];
-        return ans !== undefined && ans.trim() !== '';
-    });
-    const enriched = existing.questions.map((q) => ({
-        ...q,
-        suggestedAnswers: q.suggestedAnswers ?? buildSuggestedAnswers(q, knowledge),
-    }));
-    const suggestedDescription = specReady
-        ? buildSuggestedDescription(existing.topic, mergedAnswers, enriched)
-        : undefined;
-    const updated = {
-        ...existing,
-        questions: enriched,
-        answers: mergedAnswers,
-        isComplete: specReady,
-        contradictions: contradictions.length > 0 ? contradictions : undefined,
-        specReady,
-        interviewMode: 'multiple-choice',
-        ...(suggestedDescription !== undefined ? { suggestedDescription } : {}),
-    };
-    await knowledgeStore.addClarification(projectId, updated);
-    const result = {
-        sessionId: existing.id,
-        topic: existing.topic,
-        interviewMode: 'multiple-choice',
-        questionsCount: existing.questions.length,
-        questions: enriched.map((q) => ({
-            id: q.id,
-            question: q.question,
-            category: q.category,
-            importance: q.importance,
-            suggestedAnswers: q.suggestedAnswers,
-            ...(q.suggestedAnswers.length > 0 ? { suggestedAnswersClassification: 'candidate' } : {}),
-            options: q.options,
-            ...(q.options ? { optionsClassification: 'candidate' } : {}),
-            skipped: q.skipped,
-            answered: mergedAnswers[q.id] !== undefined,
-        })),
-        specReady,
-        confirmedChoices: buildConfirmedChoices(enriched, mergedAnswers),
-        ...(suggestedDescription !== undefined ? { suggestedDescription } : {}),
-        answeredCount: Object.keys(mergedAnswers).length,
-        ...(contradictions.length > 0
-            ? {
-                contradictions,
-                contradictionWarning: 'Potential contradictions detected — review before creating the spec.',
-            }
-            : {}),
-        instructions: specReady
-            ? 'Requirements gathered. Present the suggestedDescription to the user and ask for explicit confirmation before calling create_spec. Do NOT call create_spec automatically.'
-            : `${criticalIds.length - criticalIds.filter((id) => mergedAnswers[id]?.trim()).length} critical question(s) remaining.`,
-        message: `Session resumed. ${Object.keys(mergedAnswers).length}/${existing.questions.length} answered.`,
-        // SPEC-542: Confirmation required before calling create_spec
-        ...(specReady
-            ? {
-                confirmationRequired: {
-                    needsConfirmation: true,
-                    question: 'Do you want me to create the spec with these gathered requirements?',
-                    header: 'Create Spec?',
-                    options: [
-                        {
-                            label: 'Yes, create the spec',
-                            description: 'Proceed to call create_spec with the clarificationSessionId.',
-                        },
-                        {
-                            label: 'No, review first',
-                            description: 'Review or adjust the requirements before creating the spec.',
-                        },
-                    ],
-                    note: 'This tool does NOT create specs automatically. create_spec must be called separately after explicit user confirmation.',
-                },
-            }
-            : {}),
-    };
-    return compactResult(compactJson(result, 200));
-}
-export async function handleClarifyRequirements(params, server) {
-    const { projectId, topic, context, maxQuestions = 7, answers, sessionId } = params;
-    try {
-        // Load project knowledge — proceed with null if project not yet initialized (SPEC-020: criterion 5.1)
-        const knowledge = await knowledgeStore.getKnowledge(projectId).catch(() => null);
-        // Resume existing session if sessionId provided
-        if (sessionId) {
-            return await handleResumeSession(projectId, sessionId, answers ?? {}, knowledge);
-        }
-        // Detect contradictions in provided answers (if any)
-        const contradictions = answers && Object.keys(answers).length > 0 ? detectContradictions(answers) : [];
-        // If topic is vague (< 10 words), prepend meta-questions
-        const metaQuestions = isShortTopic(topic)
-            ? generateMetaQuestions()
-            : [];
-        // Generate main clarification questions (cap total at maxQuestions)
-        const mainMaxQ = Math.max(1, maxQuestions - metaQuestions.length);
-        const mainQuestions = generateQuestions(topic, context, knowledge, mainMaxQ);
-        const rawQuestions = [...metaQuestions, ...mainQuestions].slice(0, maxQuestions);
-        // Detect project stack for auto-skip and option filtering (SPEC-337)
-        const projectPath = knowledge?.projectPath ?? '';
-        const stack = projectPath !== ''
-            ? await detectStack(projectPath).catch(() => ({
-                framework: null,
-                language: null,
-                database: null,
-                detectedLibs: [],
-            }))
-            : { framework: null, language: null, database: null, detectedLibs: [] };
-        // Apply multiple-choice options + mark skipped questions (SPEC-337)
-        const questions = rawQuestions.map((q) => {
-            const withOptions = attachOptions(q);
-            const skipped = shouldSkipQuestion(q, stack);
-            return skipped ? { ...withOptions, skipped: true } : withOptions;
-        });
-        const detectedEvidence = [
-            ...(stack.language
-                ? [{ field: 'language', value: stack.language, source: 'project_manifest' }]
-                : knowledge?.language && knowledge.language !== 'unknown'
-                    ? [{ field: 'language', value: knowledge.language, source: 'project_knowledge' }]
-                    : []),
-            ...(stack.framework
-                ? [{ field: 'framework', value: stack.framework, source: 'project_manifest' }]
-                : knowledge?.framework
-                    ? [
-                        {
-                            field: 'framework',
-                            value: knowledge.framework,
-                            source: 'project_knowledge',
-                        },
-                    ]
-                    : []),
-            ...(stack.database
-                ? [{ field: 'database', value: stack.database, source: 'project_manifest' }]
-                : knowledge?.database && knowledge.database !== 'unknown'
-                    ? [{ field: 'database', value: knowledge.database, source: 'project_knowledge' }]
-                    : []),
-        ];
-        // Determine if spec is ready (all non-skipped critical questions have non-empty answers)
-        const criticalIds = questions
-            .filter((q) => q.importance === 'critical' && q.skipped !== true)
-            .map((q) => q.id);
-        const specReady = answers !== undefined &&
-            criticalIds.every((id) => {
-                const ans = answers[id];
-                return ans !== undefined && ans.trim() !== '';
-            });
-        // Build suggestedDescription when spec is ready (SPEC-337)
-        const currentAnswers = answers ?? {};
-        const suggestedDescription = specReady
-            ? buildSuggestedDescription(topic, currentAnswers, questions)
-            : undefined;
-        // Create a clarification session
-        const session = {
-            id: randomUUID().slice(0, 8),
-            projectId,
-            topic,
-            questions,
-            answers: currentAnswers,
-            isComplete: specReady,
-            createdAt: new Date().toISOString(),
-            contradictions: contradictions.length > 0 ? contradictions : undefined,
-            specReady,
-            interviewMode: 'multiple-choice',
-            ...(suggestedDescription !== undefined ? { suggestedDescription } : {}),
-        };
-        // Persist the session
-        await knowledgeStore.addClarification(projectId, session);
-        const result = {
-            sessionId: session.id,
-            topic,
-            interviewMode: 'multiple-choice',
-            questionsCount: questions.length,
-            hasMetaQuestions: metaQuestions.length > 0,
-            questions: questions.map((q) => ({
-                id: q.id,
-                question: q.question,
-                category: q.category,
-                importance: q.importance,
-                suggestedAnswer: q.suggestedAnswer,
-                /* v8 ignore next 1 */
-                suggestedAnswers: q.suggestedAnswers ?? [],
-                ...(q.suggestedAnswers && q.suggestedAnswers.length > 0
-                    ? { suggestedAnswersClassification: 'candidate' }
-                    : {}),
-                options: q.options,
-                ...(q.options ? { optionsClassification: 'candidate' } : {}),
-                skipped: q.skipped,
-            })),
-            detectedEvidence,
-            confirmedChoices: buildConfirmedChoices(questions, currentAnswers),
-            specReady,
-            ...(suggestedDescription !== undefined ? { suggestedDescription } : {}),
-            instructions: specReady
-                ? 'Requirements gathered. Present the suggestedDescription to the user and ask for explicit confirmation before calling create_spec. Do NOT call create_spec automatically.'
-                : 'Answer the questions above, then call create_spec with the gathered context. You can skip nice-to-have questions if the user does not have strong opinions.',
-            message: ti('tools.clarify_requirements.success', {
-                count: String(questions.length),
-                topic,
-            }),
-        };
-        if (contradictions.length > 0) {
-            result.contradictions = contradictions;
-            result.contradictionWarning =
-                'Potential contradictions detected in your answers — please review before creating the spec.';
-        }
-        // SPEC-542: When requirements are ready, add a confirmation question so the LLM
-        // MUST ask the user before calling create_spec — never create silently.
-        if (specReady) {
-            result.confirmationRequired = {
-                needsConfirmation: true,
-                question: 'Do you want me to create the spec with these gathered requirements?',
-                header: 'Create Spec?',
-                options: [
-                    {
-                        label: 'Yes, create the spec',
-                        description: 'Proceed to call create_spec with the clarificationSessionId.',
-                    },
-                    {
-                        label: 'No, review first',
-                        description: 'Review or adjust the requirements before creating the spec.',
-                    },
-                ],
-                note: 'This tool does NOT create specs automatically. create_spec must be called separately after explicit user confirmation.',
-            };
-        }
-        // SPEC-595: Elicit the first unanswered critical question directly when client supports it
-        if (server !== undefined && !specReady) {
-            const firstPending = questions.find((q) => q.importance === 'critical' &&
-                q.skipped !== true &&
-                (!currentAnswers[q.id] || currentAnswers[q.id] === ''));
-            if (firstPending !== undefined) {
-                const options = firstPending.options ?? [];
-                const enumValues = options.length > 0 && options.length <= 5
-                    ? options.map((o) => typeof o === 'string'
-                        ? o
-                        : (o.value ??
-                            o.label ??
-                            String(o)))
-                    : ['yes', 'no', 'unsure', 'other'];
-                const enumNames = options.length > 0 && options.length <= 5
-                    ? options.map((o) => typeof o === 'string' ? o : (o.label ?? String(o)))
-                    : ['Yes', 'No', 'Unsure', 'Other'];
-                const { field, property } = buildEnumSchema(firstPending.id, enumValues, enumNames, firstPending.question);
-                const schema = { type: 'object', properties: { [field]: property } };
-                const fallback = {
-                    header: firstPending.category,
-                    question: firstPending.question,
-                    multiSelect: false,
-                    options: enumValues.map((v, i) => ({
-                        label: v,
-                        description: enumNames[i] ?? v,
-                    })),
-                };
-                const outcome = await elicitOrFallback(server, firstPending.question, schema, [fallback]);
-                if (outcome.mode === 'fallback') {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `⚡ INTERACTIVE — call AskUserQuestion now with the interactiveQuestions from structuredContent`,
-                            },
-                        ],
-                        structuredContent: {
-                            ...result,
-                            interactiveQuestions: outcome.interactiveQuestions,
-                        },
-                    };
-                }
-                const elicitedAnswer = outcome.action === 'accept'
-                    ? (outcome.content?.[firstPending.id] ?? '')
-                    : '';
-                // Embed the elicited answer for the next call
-                if (elicitedAnswer) {
-                    result.elicitedAnswer = { questionId: firstPending.id, answer: elicitedAnswer };
-                    result.instructions =
-                        `Elicited answer for "${firstPending.id}": "${elicitedAnswer}". ` +
-                            `Pass it in the answers map in the next clarify_requirements call.`;
-                }
-            }
-        }
-        return compactResult(compactJson(result, 200));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: ti('errors.internalError', { message }) }],
-            isError: true,
-        };
-    }
-}
-//# sourceMappingURL=clarify-requirements.js.map

package/dist/tools/code-graph-handler.d.ts

@@ -1,6 +0,0 @@
-import type { CodeGraphSetupInput, ToolResult } from '../types/index.js';
-export declare function handleConfigureCodeGraph(input: CodeGraphSetupInput): Promise<ToolResult>;
-export declare function handleCodeGraphStatus(input: {
-    projectPath: string;
-}): Promise<ToolResult>;
-//# sourceMappingURL=code-graph-handler.d.ts.map

package/dist/tools/code-graph-handler.js

@@ -1,72 +0,0 @@
-// tools/code-graph-handler.ts — Handler for Code Graph integration tools (SPEC-376)
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { actionToProviderKey, buildProviderEntry, buildStatusResult, mergeProviderIntoConfig, } from '../engine/code-graph-configurator.js';
-const CLAUDE_JSON = '.claude.json';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-async function readClaudeJson(projectPath) {
-    try {
-        const raw = await readFile(join(projectPath, CLAUDE_JSON), 'utf8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return {};
-    }
-}
-async function writeClaudeJson(projectPath, config) {
-    await writeFile(join(projectPath, CLAUDE_JSON), JSON.stringify(config, null, 2) + '\n', 'utf8');
-}
-// ---------------------------------------------------------------------------
-// configure_code_graph
-// ---------------------------------------------------------------------------
-export async function handleConfigureCodeGraph(input) {
-    const { projectPath, action } = input;
-    if (action === 'status') {
-        return handleCodeGraphStatus({ projectPath });
-    }
-    const providerKey = actionToProviderKey(action);
-    const entry = buildProviderEntry(providerKey);
-    /* v8 ignore next 3 */
-    if (!entry) {
-        return { content: [{ type: 'text', text: `Unknown action: ${action}` }] };
-    }
-    const existing = await readClaudeJson(projectPath);
-    const updated = mergeProviderIntoConfig(existing, providerKey, entry);
-    await writeClaudeJson(projectPath, updated);
-    const lines = [
-        `Code Graph provider configured: ${providerKey}`,
-        '',
-        `Added to ${join(projectPath, CLAUDE_JSON)}:`,
-        '```json',
-        JSON.stringify({ [providerKey]: entry }, null, 2),
-        '```',
-        '',
-        providerKey === 'codegraph'
-            ? 'Initialize the project index with `npx -y @colbymchenry/codegraph init -i` from the project root before relying on graph queries.'
-            : 'Initialize the provider index using the provider documentation before relying on graph queries.',
-        '',
-        'Restart Claude Code (or your MCP client) to activate the new server.',
-    ];
-    return { content: [{ type: 'text', text: lines.join('\n') }] };
-}
-// ---------------------------------------------------------------------------
-// code_graph_status
-// ---------------------------------------------------------------------------
-export async function handleCodeGraphStatus(input) {
-    const config = await readClaudeJson(input.projectPath);
-    const result = buildStatusResult(config);
-    const lines = [
-        'Code Graph Integration Status',
-        '==============================',
-        '',
-        '| Provider | Configured |',
-        '|----------|------------|',
-        ...result.providers.map((p) => `| ${p.name} | ${p.configured ? 'yes' : 'no'} |`),
-        '',
-        `Active provider: ${result.activeProvider ?? 'none'}`,
-    ];
-    return { content: [{ type: 'text', text: lines.join('\n') }] };
-}
-//# sourceMappingURL=code-graph-handler.js.map

package/dist/tools/create-rule.d.ts

@@ -1,4 +0,0 @@
-import type { ToolResult } from '../types/index.js';
-import type { CreateRuleInput } from '../types/universal-rules/index.js';
-export declare function handleCreateRule(input: CreateRuleInput): Promise<ToolResult>;
-//# sourceMappingURL=create-rule.d.ts.map

package/dist/tools/create-rule.js

@@ -1,107 +0,0 @@
-// tools/create-rule.ts — SPEC-779: create_rule MCP tool
-// Creates a host-aware rule file for any Planu-using project.
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { detectHost } from '../engine/host-detection/detect-host.js';
-import { writeRuleForHost } from '../engine/universal-rules/host-writer.js';
-import { hashContent } from '../engine/universal-rules/user-edit-detector.js';
-import { hashProjectPath } from '../storage/base-store.js';
-import { appendAutopilotLogEntry } from '../storage/autopilot-log-store.js';
-// ---------------------------------------------------------------------------
-// Host resolution
-// ---------------------------------------------------------------------------
-/** Resolve 'auto' host to a concrete HostId. Falls back to 'claude-code'. */
-function resolveHost(input) {
-    if (input.host !== 'auto') {
-        return input.host;
-    }
-    const detected = detectHost();
-    if (detected === 'codex') {
-        return 'codex';
-    }
-    if (detected === 'gemini') {
-        return 'gemini';
-    }
-    // cursor, universal, claude-code → default to claude-code
-    return 'claude-code';
-}
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-export async function handleCreateRule(input) {
-    const { projectPath, name, content, overwriteExisting } = input;
-    const host = resolveHost(input);
-    // Build a minimal UniversalRule-compatible object for writeRuleForHost
-    const rule = {
-        id: name,
-        name,
-        description: '',
-        category: 'workflow',
-        applicableHosts: [host],
-        defaultEnabled: false,
-        buildContent: (_h) => content,
-    };
-    // Compute the expected target path for claude-code (to check overwrite protection)
-    let targetPath;
-    if (host === 'claude-code') {
-        targetPath = join(projectPath, '.claude', 'rules', `${name}.md`);
-    }
-    else if (host === 'codex') {
-        targetPath = join(projectPath, 'AGENTS.md');
-    }
-    else {
-        targetPath = join(projectPath, '.gemini', 'conventions.md');
-    }
-    // For claude-code, enforce overwrite protection on distinct content
-    if (host === 'claude-code') {
-        try {
-            const existing = await readFile(targetPath, 'utf-8');
-            const existingHash = hashContent(existing);
-            const newHash = hashContent(content);
-            if (existingHash !== newHash && overwriteExisting !== true) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Rule already exists at ${targetPath}. Pass overwriteExisting: true to replace.`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        }
-        catch {
-            // File doesn't exist yet — proceed normally
-        }
-    }
-    let writtenPath;
-    try {
-        writtenPath = await writeRuleForHost(rule, projectPath, host);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: 'text', text: `Failed to write rule: ${msg}` }],
-            isError: true,
-        };
-    }
-    // Fire-and-forget autopilot log entry
-    const projectId = hashProjectPath(projectPath);
-    void appendAutopilotLogEntry(projectId, {
-        specId: 'create_rule',
-        hookName: 'rule_created',
-        result: 'pass',
-        timestamp: new Date().toISOString(),
-        durationMs: 0,
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `Rule \`${name}\` written to \`${writtenPath}\` (host: ${host}).`,
-            },
-        ],
-        isError: false,
-    };
-}
-//# sourceMappingURL=create-rule.js.map

package/dist/tools/feedback-handler.d.ts

@@ -1,7 +0,0 @@
-import type { ToolResult, SubmitFeedbackInput, TriageFeedbackInput, ResolveFeedbackInput, SyncFeedbackInput, FeedbackStatusInput } from '../types/index.js';
-export declare function handleSubmitFeedback(input: SubmitFeedbackInput): Promise<ToolResult>;
-export declare function handleTriageFeedback(input: TriageFeedbackInput): ToolResult;
-export declare function handleResolveFeedback(input: ResolveFeedbackInput): Promise<ToolResult>;
-export declare function handleSyncFeedback(input: SyncFeedbackInput): Promise<ToolResult>;
-export declare function handleFeedbackStatus(input: FeedbackStatusInput): ToolResult;
-//# sourceMappingURL=feedback-handler.d.ts.map