@planu/cli 5.7.4 → 5.7.6

package/dist/tools/feedback-handler.js

@@ -1,150 +0,0 @@
-import { submitFeedback, getFeedback, resolveFeedback, findSimilar, getSummary, getFeedbackRemoteHealth, syncFeedbackRemote, } from '../storage/feedback-store.js';
-import { triageFeedback, formatTriageReport } from '../engine/feedback/triage.js';
-import { globalDataDir, hashProjectPath, projectDataDir } from '../storage/base-store.js';
-// ---------------------------------------------------------------------------
-// Default data directory
-// ---------------------------------------------------------------------------
-function getDataDir(projectPath) {
-    return projectPath ? projectDataDir(hashProjectPath(projectPath)) : globalDataDir();
-}
-// ---------------------------------------------------------------------------
-// Type emoji mapping
-// ---------------------------------------------------------------------------
-const TYPE_EMOJI = {
-    bug: 'Bug',
-    feature: 'Feature',
-    suggestion: 'Suggestion',
-    dx: 'DX',
-};
-// ---------------------------------------------------------------------------
-// submit_feedback handler
-// ---------------------------------------------------------------------------
-export async function handleSubmitFeedback(input) {
-    const feedbackType = input.type;
-    const dataDir = getDataDir(input.context?.projectPath);
-    const entry = await submitFeedback(dataDir, {
-        type: feedbackType,
-        title: input.title,
-        description: input.description,
-        context: input.context,
-        status: 'pending',
-        votes: 1,
-    });
-    // Check for similar feedback to warn about duplicates
-    const similar = findSimilar(dataDir, input.title, 0.4).filter((e) => e.id !== entry.id);
-    const topSimilar = similar.sort((a, b) => (b.votes ?? 0) - (a.votes ?? 0))[0];
-    const lines = [
-        `Feedback submitted: **${entry.id}**`,
-        '',
-        '| Field | Value |',
-        '|-------|-------|',
-        `| Type | ${TYPE_EMOJI[feedbackType]} |`,
-        `| Title | ${entry.title} |`,
-        `| Status | Pending |`,
-        `| Remote Delivery | ${entry.remoteDelivery?.status ?? 'pending'} |`,
-    ];
-    if (topSimilar !== undefined) {
-        lines.push('');
-        lines.push(`Similar feedback found: ${topSimilar.id} (${topSimilar.votes ?? 1} votes) — consider voting instead of duplicating.`);
-    }
-    return { content: [{ type: 'text', text: lines.join('\n') }] };
-}
-// ---------------------------------------------------------------------------
-// triage_feedback handler
-// ---------------------------------------------------------------------------
-export function handleTriageFeedback(input) {
-    const dataDir = getDataDir();
-    const filterType = input.filter;
-    const entries = getFeedback(dataDir, filterType !== undefined ? { type: filterType } : undefined);
-    const groups = triageFeedback(entries);
-    const report = formatTriageReport(groups);
-    const summary = getSummaryLine(entries.length, groups.length);
-    const text = [summary, '', report].join('\n');
-    return { content: [{ type: 'text', text }] };
-}
-function getSummaryLine(total, groups) {
-    return `${total} feedback item(s) → ${groups} triage group(s)`;
-}
-// ---------------------------------------------------------------------------
-// resolve_feedback handler
-// ---------------------------------------------------------------------------
-export async function handleResolveFeedback(input) {
-    const dataDir = getDataDir();
-    const resolved = await resolveFeedback(dataDir, input.feedbackId, input.specId, input.prUrl, input.notes);
-    if (resolved === null) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error: Feedback ${input.feedbackId} not found. Check the ID and try again.`,
-                },
-            ],
-            isError: true,
-        };
-    }
-    const lines = [
-        `Feedback resolved: **${resolved.id}**`,
-        '',
-        '| Field | Value |',
-        '|-------|-------|',
-        `| Title | ${resolved.title} |`,
-        `| Status | Resolved |`,
-        `| Resolved At | ${resolved.resolvedAt ?? 'now'} |`,
-    ];
-    if (resolved.specId) {
-        lines.push(`| Linked Spec | ${resolved.specId} |`);
-    }
-    if (resolved.prUrl) {
-        lines.push(`| PR URL | ${resolved.prUrl} |`);
-    }
-    if (resolved.resolvedNotes) {
-        lines.push('', `**Notes:** ${resolved.resolvedNotes}`);
-    }
-    return { content: [{ type: 'text', text: lines.join('\n') }] };
-}
-// ---------------------------------------------------------------------------
-// sync_feedback handler
-// ---------------------------------------------------------------------------
-export async function handleSyncFeedback(input) {
-    const dataDir = getDataDir(input.projectPath);
-    const summary = await syncFeedbackRemote(dataDir, input);
-    const lines = [
-        'Feedback remote sync complete.',
-        '',
-        '| Field | Value |',
-        '|-------|-------|',
-        `| Processed | ${summary.total} |`,
-        `| Synced | ${summary.synced} |`,
-        `| Failed | ${summary.failed} |`,
-        `| Skipped | ${summary.skipped} |`,
-        `| Already Synced | ${summary.alreadySynced} |`,
-    ];
-    if (summary.processedIds.length > 0) {
-        lines.push(`| Processed IDs | ${summary.processedIds.join(', ')} |`);
-    }
-    return { content: [{ type: 'text', text: lines.join('\n') }] };
-}
-// ---------------------------------------------------------------------------
-// feedback_status handler
-// ---------------------------------------------------------------------------
-export function handleFeedbackStatus(input) {
-    const dataDir = getDataDir(input.projectPath);
-    const summary = getSummary(dataDir);
-    const remote = getFeedbackRemoteHealth(dataDir);
-    const lines = [
-        'Feedback status',
-        '',
-        '| Field | Value |',
-        '|-------|-------|',
-        `| Total | ${summary.total} |`,
-        `| Pending Local | ${summary.pending} |`,
-        `| Resolved Local | ${summary.resolved} |`,
-        `| Remote Pending | ${remote.byRemoteStatus.pending} |`,
-        `| Remote Synced | ${remote.byRemoteStatus.synced} |`,
-        `| Remote Failed | ${remote.byRemoteStatus.failed} |`,
-        `| Remote Skipped | ${remote.byRemoteStatus.skipped} |`,
-        `| Retryable | ${remote.retryable} |`,
-    ];
-    return { content: [{ type: 'text', text: lines.join('\n') }] };
-}
-//# sourceMappingURL=feedback-handler.js.map

package/dist/tools/semantic-search-handler.d.ts

@@ -1,7 +0,0 @@
-import type { ToolResult, SemanticSearchArgs } from '../types/index.js';
-/**
- * Handle a semantic_search request.
- * Embeds the query with TF-IDF, then searches the vector backend.
- */
-export declare function handleSemanticSearch(args: SemanticSearchArgs): Promise<ToolResult>;
-//# sourceMappingURL=semantic-search-handler.d.ts.map

package/dist/tools/semantic-search-handler.js

@@ -1,71 +0,0 @@
-// tools/semantic-search-handler.ts — Handler for semantic_search tool.
-// SPEC-075 AC-07: Generates TF-IDF embedding of query, searches backend.
-import { getOrCreateBackend } from '../storage/vector-store/backend-factory.js';
-import { SemanticIndexStore } from '../storage/semantic-index-store.js';
-/**
- * Handle a semantic_search request.
- * Embeds the query with TF-IDF, then searches the vector backend.
- */
-export async function handleSemanticSearch(args) {
-    const { projectId, query, scope = 'all', topK = 5, threshold = 0.3 } = args;
-    if (!projectId) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: 'Error: No project ID provided. Run init_project first.',
-                },
-            ],
-            isError: true,
-        };
-    }
-    const backend = await getOrCreateBackend(projectId);
-    // Build a TF-IDF engine from existing documents so IDF is accurate
-    const type = scope === 'all' ? undefined : scope;
-    const allDocs = await backend.getAll(type);
-    if (allDocs.length === 0) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `No documents found in scope "${scope}". Add specs, patterns, or knowledge first.`,
-                },
-            ],
-        };
-    }
-    // SPEC-1345: load the persisted TF-IDF index for this scope, incrementally
-    // reconciled against the current corpus (no full rebuild for unchanged docs).
-    const indexStore = new SemanticIndexStore(projectId, scope);
-    const tfidf = await indexStore.loadOrBuild(allDocs.map((doc) => ({ id: doc.id, content: doc.content })));
-    // Embed the query
-    const queryEmbedding = tfidf.embed(query);
-    // Search
-    const results = await backend.searchSimilar(queryEmbedding, topK, threshold, type);
-    if (results.length === 0) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `No results found for "${query}" in scope "${scope}" with threshold ${String(threshold)}. Try a lower threshold or broader scope.`,
-                },
-            ],
-        };
-    }
-    const formatted = results.map((r, i) => {
-        const truncated = r.entry.content.length > 200 ? `${r.entry.content.slice(0, 200)}...` : r.entry.content;
-        return [
-            `${String(i + 1)}. [${r.entry.type}] ${r.entry.id}`,
-            `   Similarity: ${r.similarity.toFixed(3)}`,
-            `   ${truncated}`,
-        ].join('\n');
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `Found ${String(results.length)} results for "${query}":\n\n${formatted.join('\n\n')}`,
-            },
-        ],
-    };
-}
-//# sourceMappingURL=semantic-search-handler.js.map

package/dist/tools/skill-registry/search.d.ts

@@ -1,11 +0,0 @@
-import type { ToolResult, SkillRegistrySource } from '../../types/index.js';
-export declare function loadRegistries(): SkillRegistrySource[];
-export declare function handleSkillSearch(params: {
-    query: string;
-    registry?: string;
-    stack?: string;
-    limit?: number;
-    /** SPEC-606: Specific sources to search (universal engine). */
-    sources?: string[];
-}): Promise<ToolResult>;
-//# sourceMappingURL=search.d.ts.map

package/dist/tools/skill-registry/search.js

@@ -1,159 +0,0 @@
-// @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
-// tools/skill-registry/search.ts — Handler for skill_search tool (SPEC-150, updated SPEC-606)
-import { searchAllRegistries } from '../../engine/skill-registry/index.js';
-import { searchSkillsUniversal } from '../../engine/skill-discovery/index.js';
-import { formatSuccess, toolResult } from '../response-helpers.js';
-import { ti } from '../../i18n/index.js';
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const DEFAULT_REGISTRIES = [
-    {
-        id: 'builtin',
-        name: 'Planu Built-in Skills',
-        url: 'local://skill-catalog',
-        type: 'api',
-        priority: 0,
-        enabled: true,
-    },
-    {
-        id: 'anthropic',
-        name: 'Anthropic Official Skills',
-        url: 'https://github.com/anthropics/skills',
-        type: 'github',
-        priority: 1,
-        enabled: true,
-    },
-    {
-        id: 'agentskill',
-        name: 'AgentSkill.sh',
-        url: 'https://agentskill.sh',
-        type: 'api',
-        priority: 2,
-        enabled: true,
-    },
-    {
-        id: 'skillssh',
-        name: 'Skills.sh',
-        url: 'https://skills.sh',
-        type: 'npm',
-        priority: 3,
-        enabled: true,
-    },
-];
-export function loadRegistries() {
-    // Try compiled path first (dist/config/), then source path (src/config/)
-    const compiledPath = join(__dirname, '../../config/skill-registries.json');
-    const sourcePath = join(__dirname, '../../../src/config/skill-registries.json');
-    for (const configPath of [compiledPath, sourcePath]) {
-        let raw;
-        try {
-            raw = readFileSync(configPath, 'utf-8');
-        }
-        catch {
-            // File not found at this path — try next
-            continue;
-        }
-        if (!raw.trim()) {
-            // Empty file — skip, try next path
-            continue;
-        }
-        try {
-            return JSON.parse(raw);
-        }
-        catch {
-            console.warn('[skill_search] skill-registries.json is corrupted, using defaults');
-            return DEFAULT_REGISTRIES;
-        }
-    }
-    return DEFAULT_REGISTRIES;
-}
-export async function handleSkillSearch(params) {
-    try {
-        const registries = loadRegistries();
-        // Guard: query must be a non-empty string to avoid returning unfiltered catalog dumps
-        const query = typeof params.query === 'string' ? params.query.trim() : '';
-        if (query.length === 0) {
-            return toolResult(formatSuccess('No query provided', 'Provide a search term to find skills. Example: `skill_search({ query: "testing", projectPath: "..." })`'), { results: [], count: 0 });
-        }
-        const limit = Math.max(1, Math.min(params.limit ?? 10, 50));
-        // SPEC-606: When sources are specified, delegate to the universal discovery engine.
-        // Otherwise, use the existing registry-based search for backward compatibility.
-        if (params.sources && params.sources.length > 0) {
-            const universalResults = await searchSkillsUniversal(query, {
-                stack: params.stack,
-                limit,
-                sources: params.sources,
-            });
-            const lines = [];
-            if (universalResults.length === 0) {
-                lines.push(`No skills found matching **"${query}"** in sources: ${params.sources.join(', ')}.`);
-                lines.push('');
-                lines.push('Try a broader query or remove the sources filter.');
-            }
-            else {
-                lines.push('| # | Skill | Source | Description |');
-                lines.push('|---|-------|--------|-------------|');
-                universalResults.forEach((r, i) => {
-                    const desc = r.description.length > 80 ? r.description.slice(0, 77) + '...' : r.description;
-                    lines.push(`| ${String(i + 1)} | **${r.name}** | ${r.source} | ${desc} |`);
-                });
-                lines.push('');
-                lines.push('Install with: `skill_install({ name: "skill-name", projectPath: "..." })`');
-            }
-            const markdown = formatSuccess(`Found ${String(universalResults.length)} skill${universalResults.length !== 1 ? 's' : ''} (universal search)`, lines.join('\n'));
-            return toolResult(markdown, { results: universalResults, count: universalResults.length });
-        }
-        const searchParams = {
-            query,
-            registry: params.registry,
-            stack: params.stack,
-            limit,
-        };
-        const enabledCount = registries.filter((r) => {
-            if (!r.enabled) {
-                return false;
-            }
-            if (searchParams.registry &&
-                searchParams.registry !== 'all' &&
-                r.id !== searchParams.registry) {
-                return false;
-            }
-            return true;
-        }).length;
-        const results = await searchAllRegistries(searchParams, registries);
-        const lines = [];
-        if (results.length === 0) {
-            if (enabledCount === 0) {
-                lines.push('No skill registries are enabled. Check your `skill-registries.json` configuration.');
-            }
-            else {
-                lines.push(`No skills found matching **"${query}"**.`);
-                lines.push('');
-                lines.push('Suggestions:');
-                lines.push('- Try a broader search term (e.g., "test" instead of "unit-testing")');
-                lines.push('- Omit the `registry` filter to search all registries');
-                lines.push('- Check network connectivity to skill registries');
-                lines.push('- Use `sources: ["github"]` for broader universal search (SPEC-606)');
-            }
-        }
-        else {
-            lines.push('| # | Skill | Source | Description |');
-            lines.push('|---|-------|--------|-------------|');
-            results.forEach((r, i) => {
-                const desc = r.description.length > 80 ? r.description.slice(0, 77) + '...' : r.description;
-                lines.push(`| ${String(i + 1)} | **${r.name}** | ${r.source} | ${desc} |`);
-            });
-            lines.push('');
-            lines.push('Install with: `skill_install({ name: "skill-name", projectPath: "..." })`');
-        }
-        const markdown = formatSuccess(`Found ${String(results.length)} skill${results.length !== 1 ? 's' : ''}`, lines.join('\n'));
-        return toolResult(markdown, { results, count: results.length });
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return toolResult(ti('errors.internalError', { message: msg }) + (msg ? ` ${msg}` : ''), undefined, true);
-    }
-}
-//# sourceMappingURL=search.js.map