@planu/cli 4.14.1 → 5.0.0

package/dist/tools/license-status.js

@@ -1,93 +0,0 @@
-// tools/license-status.ts — Handler for license_status MCP tool.
-// Shows current tier, limits, usage, and upgrade URL.
-import { licenseStore } from '../storage/index.js';
-import { getTierLimits, loadLicensePlans } from '../engine/license-validator.js';
-import { getCurrentTier } from './license-gate.js';
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-function getVersion() {
-    try {
-        const dir = dirname(fileURLToPath(import.meta.url));
-        const pkg = JSON.parse(readFileSync(join(dir, '../../package.json'), 'utf-8'));
-        return pkg.version;
-    }
-    catch {
-        return 'unknown';
-    }
-}
-export async function handleLicenseStatus(_args) {
-    const [state, tier] = await Promise.all([licenseStore.getLicenseState(), getCurrentTier()]);
-    const limits = getTierLimits(tier);
-    const config = loadLicensePlans();
-    const projectCount = await licenseStore.countActiveProjects();
-    const lines = [];
-    lines.push(`## Planu License Status`);
-    lines.push('');
-    const tierLabel = tier.charAt(0).toUpperCase() + tier.slice(1);
-    const totalTools = config.freeTools.length + config.proTools.length + config.alwaysAllowed.length;
-    lines.push(`**Version:** ${getVersion()}`);
-    lines.push(`**Plan:** ${tierLabel}`);
-    if (state?.customerName) {
-        lines.push(`**Customer:** ${state.customerName} (${state.customerEmail})`);
-        lines.push(`**Variant:** ${state.variantName}`);
-        lines.push(`**Activated:** ${state.activatedAt}`);
-        lines.push(`**Last validated:** ${state.lastValidatedAt}`);
-    }
-    if (tier === 'free') {
-        const freeAvailable = config.freeTools.length + config.alwaysAllowed.length;
-        lines.push(`**Tools available:** ${String(freeAvailable)} of ${String(totalTools)}`);
-    }
-    else {
-        lines.push(`**Tools available:** ${String(totalTools)} of ${String(totalTools)}`);
-    }
-    lines.push('');
-    lines.push('### Limits');
-    lines.push(`- Projects: ${String(projectCount)} / ${limits.maxProjects >= 999999 ? '∞' : String(limits.maxProjects)}`);
-    lines.push(`- Active specs: ${limits.maxActiveSpecs >= 999999 ? '∞' : String(limits.maxActiveSpecs)} per project`);
-    if (state?.customerName && state.activationLimit > 0) {
-        lines.push(`- Activation slots: ${String(state.activationUsage)} / ${String(state.activationLimit)}`);
-    }
-    if (tier === 'free') {
-        lines.push('');
-        lines.push('### Upgrade');
-        lines.push(`Unlock all ${String(totalTools)} tools, 10 projects, and unlimited specs.`);
-        lines.push(`→ ${config.upgradeUrl}`);
-        lines.push('');
-        lines.push('Already have a key? Use `activate_license` to activate it.');
-    }
-    const structured = {
-        version: getVersion(),
-        plan: tierLabel,
-        toolsAvailable: tier === 'free' ? config.freeTools.length + config.alwaysAllowed.length : totalTools,
-        toolsTotal: totalTools,
-        limits: {
-            maxProjects: limits.maxProjects,
-            currentProjects: projectCount,
-            maxActiveSpecs: limits.maxActiveSpecs,
-        },
-    };
-    if (state?.customerName) {
-        structured.customer = {
-            name: state.customerName,
-            email: state.customerEmail,
-            variant: state.variantName,
-            activatedAt: state.activatedAt,
-            lastValidatedAt: state.lastValidatedAt,
-        };
-        if (state.customerName && state.activationLimit > 0) {
-            structured.activationSlots = {
-                used: state.activationUsage,
-                total: state.activationLimit,
-            };
-        }
-    }
-    if (tier === 'free') {
-        structured.upgradeUrl = config.upgradeUrl;
-    }
-    return {
-        content: [{ type: 'text', text: lines.join('\n') }],
-        structuredContent: structured,
-    };
-}
-//# sourceMappingURL=license-status.js.map

package/dist/tools/list-sessions.d.ts

@@ -1,3 +0,0 @@
-import type { ToolResult, ListSessionsInput } from '../types/index.js';
-export declare function handleListSessions(params: ListSessionsInput): Promise<ToolResult>;
-//# sourceMappingURL=list-sessions.d.ts.map

package/dist/tools/list-sessions.js

@@ -1,46 +0,0 @@
-import { hashProjectPath } from '../storage/base-store.js';
-import * as sessionStore from '../storage/session-store.js';
-import { t, ti } from '../i18n/index.js';
-export async function handleListSessions(params) {
-    const projectId = hashProjectPath(params.projectPath);
-    const limit = params.limit ?? 10;
-    try {
-        const items = await sessionStore.listItems(projectId, limit);
-        const lines = [];
-        lines.push(t('tools.response.sessionsTitle'));
-        lines.push('');
-        if (items.length === 0) {
-            lines.push(t('tools.response.noSessions'));
-        }
-        else {
-            lines.push(ti('tools.response.sessionsFound', { count: items.length }));
-            lines.push('');
-            for (const session of items) {
-                lines.push(`- **${session.id}** | created: ${session.startedAt} | saved: ${session.lastSavedAt}`);
-            }
-        }
-        lines.push('');
-        lines.push('🚀 **Next Steps**');
-        lines.push('1. Use `restore_session` to resume a session');
-        lines.push('2. Use `export_session` to save session data');
-        const sessionTips = {
-            naming: 'Name sessions at start: claude -n auth-refactor  |  Or rename during: /rename auth-refactor',
-            resume: 'Resume by name: claude --resume auth-refactor  |  Most recent: claude --continue',
-            fromPr: 'Resume PR session: claude --from-pr 123 (auto-linked when PR created inside Claude Code)',
-            pickerShortcuts: 'In /resume picker: P=preview, R=rename, B=filter by branch, /=search',
-            btw: 'Use /btw for quick side questions — answer appears in overlay, never enters conversation history',
-        };
-        return {
-            content: [{ type: 'text', text: lines.join('\n') }],
-            sessionTips,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error listing sessions: ${message}` }],
-            isError: true,
-        };
-    }
-}
-//# sourceMappingURL=list-sessions.js.map

package/dist/tools/planu-session-checkpoint.d.ts

@@ -1,6 +0,0 @@
-import type { ToolResult } from '../types/index.js';
-export declare function handlePlanSessionCheckpoint(input: {
-    projectPath?: string;
-    dryRun?: boolean;
-}): Promise<ToolResult>;
-//# sourceMappingURL=planu-session-checkpoint.d.ts.map

package/dist/tools/planu-session-checkpoint.js

@@ -1,42 +0,0 @@
-import { runCheckpoint } from '../engine/session-safeguard/checkpoint-runner.js';
-import { readPlanuConfig } from '../engine/planu-config-writer.js';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-const DEFAULT_AUTOPUSH_BRANCHES = ['feat/*', 'fix/*', 'chore/*'];
-function resolveProjectPath(input) {
-    return input ?? process.cwd();
-}
-async function loadProjectConfig(projectPath) {
-    const configPath = join(projectPath, 'planu', 'config.json');
-    const config = await readPlanuConfig(configPath, readFile);
-    return {
-        autopush: config?.autopush ?? false,
-        autopushBranches: config?.autopushBranches ?? DEFAULT_AUTOPUSH_BRANCHES,
-    };
-}
-export async function handlePlanSessionCheckpoint(input) {
-    const projectPath = resolveProjectPath(input.projectPath);
-    const { autopush, autopushBranches } = await loadProjectConfig(projectPath);
-    const result = await runCheckpoint({
-        projectPath,
-        dryRun: input.dryRun ?? false,
-        autopush,
-        autopushBranches,
-    });
-    const lines = [result.humanSummary, ''];
-    if (result.unpushedCommits && result.unpushedCommits.oldestAgeHours >= 2) {
-        const u = result.unpushedCommits;
-        lines.push(`WARNING: ${String(u.count)} commit(s) unpushed for ${String(u.oldestAgeHours)}h on branch ${u.branch}. Run git push or enable autopush.`);
-    }
-    if (result.pushed?.pushed === true) {
-        lines.push(`Pushed ${String(result.pushed.commitsPushed)} commit(s) to ${result.pushed.ref}`);
-    }
-    lines.push('');
-    lines.push(`session-context refreshed: ${String(result.sessionContextRefreshed)}`);
-    lines.push(`learnings flushed: ${String(result.learningsFlushed)}`);
-    lines.push(`unpushed commits: ${String(result.unpushedCommits?.count ?? 0)}`);
-    return {
-        content: [{ type: 'text', text: lines.join('\n').trim() }],
-    };
-}
-//# sourceMappingURL=planu-session-checkpoint.js.map

package/dist/tools/restore-session.d.ts

@@ -1,3 +0,0 @@
-import type { ToolResult, RestoreSessionInput } from '../types/index.js';
-export declare function handleRestoreSession(params: RestoreSessionInput): Promise<ToolResult>;
-//# sourceMappingURL=restore-session.d.ts.map

package/dist/tools/restore-session.js

@@ -1,71 +0,0 @@
-import { hashProjectPath } from '../storage/base-store.js';
-import * as sessionStore from '../storage/session-store.js';
-import { diffSessions, formatDiffSummary } from '../engine/session/session-diff.js';
-import { compactJson } from './output-formatter.js';
-export async function handleRestoreSession(params) {
-    const projectId = hashProjectPath(params.projectPath);
-    // Handle fromPr shortcut — returns the resume command without touching session storage
-    if (params.fromPr !== undefined) {
-        const n = params.fromPr;
-        const result = {
-            resumeCommand: `claude --from-pr ${n}`,
-            description: `Resumes the Claude Code session that created or was linked to PR #${n}`,
-            tip: 'Sessions auto-link when you use gh pr create inside Claude Code',
-        };
-        return { content: [{ type: 'text', text: compactJson(result) }] };
-    }
-    try {
-        let session;
-        if (params.sessionId) {
-            session = await sessionStore.load(projectId, params.sessionId);
-        }
-        else {
-            session = await sessionStore.getLatest(projectId);
-        }
-        if (!session) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: compactJson({
-                            message: 'No sessions found for this project. Start working and sessions will be saved automatically.',
-                            projectId,
-                        }),
-                    },
-                ],
-            };
-        }
-        // Try to compute diff with the second-latest session
-        let diffSummary = '';
-        const allSessions = await sessionStore.list(projectId);
-        if (allSessions.length >= 2) {
-            const previous = allSessions[1];
-            if (previous) {
-                const diff = diffSessions(previous, session);
-                diffSummary = formatDiffSummary(diff);
-            }
-        }
-        const result = {
-            sessionId: session.id,
-            startedAt: session.startedAt,
-            lastSavedAt: session.lastSavedAt,
-            contextSummary: session.contextSummary,
-            activeSpecs: session.activeSpecs,
-            pendingDecisions: session.decisions.slice(-5),
-            toolCallCount: session.toolCallCount,
-            diffSummary: diffSummary || undefined,
-            message: 'Session restored successfully.',
-        };
-        return {
-            content: [{ type: 'text', text: compactJson(result, 60) }],
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error restoring session: ${message}` }],
-            isError: true,
-        };
-    }
-}
-//# sourceMappingURL=restore-session.js.map

package/dist/tools/spec-history.d.ts

@@ -1,3 +0,0 @@
-import type { SpecHistoryInput, ToolResult } from '../types/index.js';
-export declare function handleSpecHistory(params: SpecHistoryInput): Promise<ToolResult>;
-//# sourceMappingURL=spec-history.d.ts.map

package/dist/tools/spec-history.js

@@ -1,59 +0,0 @@
-import { readChangelog } from '../engine/spec-changelog/index.js';
-import { compactResult } from './output-formatter.js';
-const VALID_ENTRY_TYPES = [
-    'criteria_added',
-    'criteria_removed',
-    'status_changed',
-    'scope_changed',
-    'progress_updated',
-    'reconciled',
-];
-function parseFilterTypes(filter) {
-    return filter
-        .split(',')
-        .map((s) => s.trim())
-        .filter((t) => VALID_ENTRY_TYPES.includes(t));
-}
-export async function handleSpecHistory(params) {
-    const { specId, specDir, filter } = params;
-    try {
-        const changelog = await readChangelog({ specDir, specId });
-        if (!changelog) {
-            return compactResult(JSON.stringify({
-                specId,
-                entries: [],
-                totalEntries: 0,
-                filtered: false,
-                message: `No hay CHANGELOG.md para ${specId}. El changelog se crea automaticamente cuando se ejecuta reconcile_spec o update_status sobre la spec.`,
-            }, null, 2));
-        }
-        let entries = changelog.entries;
-        let filtered = false;
-        if (filter) {
-            const filterTypes = parseFilterTypes(filter);
-            if (filterTypes.length > 0) {
-                entries = entries.filter((e) => filterTypes.includes(e.type));
-                filtered = true;
-            }
-        }
-        const message = entries.length === 0 && filtered
-            ? 'No hay entradas del tipo solicitado'
-            : `${entries.length} entrada${entries.length !== 1 ? 's' : ''} encontrada${entries.length !== 1 ? 's' : ''} en el changelog de ${specId}`;
-        const result = {
-            specId,
-            entries,
-            totalEntries: entries.length,
-            filtered,
-            message,
-        };
-        return compactResult(JSON.stringify(result, null, 2));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error reading spec history: ${message}` }],
-            isError: true,
-        };
-    }
-}
-//# sourceMappingURL=spec-history.js.map

package/dist/tools/webhook.d.ts

@@ -1,6 +0,0 @@
-import type { ToolResult, StartWebhookInput, StopWebhookInput, WebhookStatusInput, WebhookServerState } from '../types/index.js';
-export declare function handleStartWebhook(args: StartWebhookInput): Promise<ToolResult>;
-export declare function handleStopWebhook(_args: StopWebhookInput): Promise<ToolResult>;
-export declare function handleWebhookStatus(args: WebhookStatusInput): ToolResult;
-export declare function formatStateForDisplay(state: WebhookServerState): string;
-//# sourceMappingURL=webhook.d.ts.map

package/dist/tools/webhook.js

@@ -1,150 +0,0 @@
-// tools/webhook.ts — Handlers for webhook management MCP tools.
-// start_webhook, stop_webhook, webhook_status
-import { startWebhookServer, stopWebhookServer, getWebhookState, setWebhookSecret, } from '../engine/webhook/index.js';
-// ---------------------------------------------------------------------------
-// Tool handlers
-// ---------------------------------------------------------------------------
-export async function handleStartWebhook(args) {
-    const port = args.port ?? 2358;
-    const secret = args.secret ?? '';
-    if (port < 1 || port > 65535) {
-        return {
-            content: [{ type: 'text', text: 'Error: port must be between 1 and 65535.' }],
-            isError: true,
-        };
-    }
-    const current = getWebhookState();
-    if (current.running) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [
-                        'Webhook server is already running.',
-                        `Port: ${String(current.port)}`,
-                        `Started: ${current.startedAt ?? 'unknown'}`,
-                        '',
-                        'Use stop_webhook first to restart on a different port.',
-                    ].join('\n'),
-                },
-            ],
-        };
-    }
-    if (secret) {
-        setWebhookSecret(secret);
-    }
-    try {
-        const state = await startWebhookServer(port);
-        const secretMsg = secret
-            ? 'HMAC-SHA256 signature validation enabled.'
-            : 'Warning: no webhook secret set — all requests will be accepted.';
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [
-                        'Webhook server started.',
-                        `URL: http://localhost:${String(state.port)}/`,
-                        `Port: ${String(state.port)}`,
-                        `Started: ${state.startedAt ?? 'unknown'}`,
-                        '',
-                        secretMsg,
-                        '',
-                        'Configure this URL in your Lemon Squeezy dashboard under:',
-                        '  Settings > Webhooks > Add webhook',
-                        '',
-                        'Supported events:',
-                        '  • subscription_cancelled',
-                        '  • subscription_updated',
-                        '  • license_key_created',
-                    ].join('\n'),
-                },
-            ],
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [
-                        `Failed to start webhook server: ${message}`,
-                        '',
-                        'Common causes:',
-                        `• Port ${String(port)} is already in use — try a different port`,
-                        '• Insufficient permissions for ports below 1024',
-                    ].join('\n'),
-                },
-            ],
-            isError: true,
-        };
-    }
-}
-export async function handleStopWebhook(_args) {
-    const current = getWebhookState();
-    if (!current.running) {
-        return {
-            content: [{ type: 'text', text: 'Webhook server is not running.' }],
-        };
-    }
-    // force flag reserved for future use (e.g., drop active connections)
-    try {
-        await stopWebhookServer();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [
-                        'Webhook server stopped.',
-                        `Events processed during session: ${String(current.eventsProcessed)}`,
-                    ].join('\n'),
-                },
-            ],
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: 'text', text: `Failed to stop webhook server: ${message}` }],
-            isError: true,
-        };
-    }
-}
-export function handleWebhookStatus(args) {
-    const state = getWebhookState();
-    const includeEvents = args.includeEvents ?? true;
-    const lines = [
-        `Status: ${state.running ? 'RUNNING' : 'STOPPED'}`,
-        `Port: ${String(state.port)}`,
-        `Started: ${state.startedAt ?? 'N/A'}`,
-        `Events processed: ${String(state.eventsProcessed)}`,
-    ];
-    if (includeEvents && state.recentEvents.length > 0) {
-        lines.push('', 'Recent events:');
-        for (const event of state.recentEvents) {
-            const status = event.processed ? 'OK' : 'FAIL';
-            lines.push(`  [${status}] ${event.receivedAt} | ${event.eventType} | ${event.summary}`);
-        }
-    }
-    else if (includeEvents) {
-        lines.push('', 'No events received yet.');
-    }
-    if (!state.running) {
-        lines.push('', 'Use start_webhook to begin receiving Lemon Squeezy events.');
-    }
-    return {
-        content: [{ type: 'text', text: lines.join('\n') }],
-    };
-}
-// ---------------------------------------------------------------------------
-// Internal helper (exported for testing)
-// ---------------------------------------------------------------------------
-export function formatStateForDisplay(state) {
-    return [
-        `running=${String(state.running)}`,
-        `port=${String(state.port)}`,
-        `eventsProcessed=${String(state.eventsProcessed)}`,
-    ].join(', ');
-}
-//# sourceMappingURL=webhook.js.map

package/dist/types/changelog.d.ts

@@ -1,49 +0,0 @@
-export type ChangelogEntryType = 'criteria_added' | 'criteria_removed' | 'status_changed' | 'scope_changed' | 'progress_updated' | 'reconciled';
-export interface CriteriaDiff {
-    added: string[];
-    removed: string[];
-    modified: {
-        before: string;
-        after: string;
-    }[];
-}
-export interface SpecSnapshot {
-    criteriaCount: number;
-    completedCount: number;
-    status: string;
-}
-export interface SpecChangelogEntry {
-    timestamp: string;
-    type: ChangelogEntryType;
-    description: string;
-    triggeredBy: string;
-    before?: SpecSnapshot;
-    after?: SpecSnapshot;
-    diff?: CriteriaDiff;
-}
-export interface SpecChangelogData {
-    specId: string;
-    entries: SpecChangelogEntry[];
-}
-export interface AppendChangelogOptions {
-    specDir: string;
-    specId: string;
-    entry: SpecChangelogEntry;
-}
-export interface ReadChangelogOptions {
-    specDir: string;
-    specId: string;
-}
-export interface SpecHistoryInput {
-    specId: string;
-    specDir: string;
-    filter?: string;
-}
-export interface SpecHistoryResult {
-    specId: string;
-    entries: SpecChangelogEntry[];
-    totalEntries: number;
-    filtered: boolean;
-    message: string;
-}
-//# sourceMappingURL=changelog.d.ts.map

package/dist/types/changelog.js

@@ -1,3 +0,0 @@
-// types/changelog.ts — Changelog and spec diff types for SPEC-067
-export {};
-//# sourceMappingURL=changelog.js.map

package/dist/types/licensing.d.ts

@@ -1,109 +0,0 @@
-import type { PricingTier } from './common/primitives.js';
-export interface LicenseState {
-    /** License key from Lemon Squeezy */
-    readonly licenseKey: string;
-    /** Unique instance identifier for this activation */
-    readonly instanceId: string;
-    /** Resolved tier from the license variant */
-    readonly tier: PricingTier;
-    /** ISO 8601 timestamp of when the license was activated locally */
-    readonly activatedAt: string;
-    /** ISO 8601 timestamp of the last successful remote validation */
-    readonly lastValidatedAt: string;
-    /** Lemon Squeezy variant name (e.g. "Planu Pro Monthly") */
-    readonly variantName: string;
-    /** Customer name from Lemon Squeezy */
-    readonly customerName: string;
-    /** Customer email from Lemon Squeezy */
-    readonly customerEmail: string;
-    /** SHA-256 fingerprint of the machine that activated this license */
-    readonly machineFingerprint: string;
-    /** Maximum number of activations allowed by Lemon Squeezy */
-    readonly activationLimit: number;
-    /** Current number of activations used */
-    readonly activationUsage: number;
-}
-export interface TierLimits {
-    readonly maxProjects: number;
-    readonly maxActiveSpecs: number;
-}
-export interface LicensePlanConfig {
-    readonly tiers: Record<PricingTier, TierLimits>;
-    readonly freeTools: readonly string[];
-    readonly proTools: readonly string[];
-    readonly alwaysAllowed: readonly string[];
-    readonly upgradeUrl: string;
-    /**
-     * ISO date string (YYYY-MM-DD). Until this date all PRO tools are accessible
-     * to free-tier users — promotional "open access" window.
-     */
-    readonly freeUntil?: string;
-}
-export interface LicenseCheckResult {
-    readonly allowed: boolean;
-    readonly currentTier: PricingTier;
-    readonly requiredTier: PricingTier;
-    readonly message: string;
-}
-export interface LemonSqueezyMeta {
-    readonly store_id: number;
-    readonly order_id: number;
-    readonly order_item_id: number;
-    readonly product_id: number;
-    readonly product_name: string;
-    readonly variant_id: number;
-    readonly variant_name: string;
-    readonly customer_id: number;
-    readonly customer_name: string;
-    readonly customer_email: string;
-}
-export interface LemonSqueezyInstance {
-    readonly id: string;
-    readonly name: string;
-    readonly created_at: string;
-}
-export interface LemonSqueezyActivateResponse {
-    readonly activated: boolean;
-    readonly error: string | null;
-    readonly license_key: {
-        readonly id: number;
-        readonly status: string;
-        readonly key: string;
-        readonly activation_limit: number;
-        readonly activation_usage: number;
-        readonly created_at: string;
-        readonly expires_at: string | null;
-    };
-    readonly instance: LemonSqueezyInstance;
-    readonly meta: LemonSqueezyMeta;
-}
-export interface LemonSqueezyValidateResponse {
-    readonly valid: boolean;
-    readonly error: string | null;
-    readonly license_key: {
-        readonly id: number;
-        readonly status: string;
-        readonly key: string;
-        readonly activation_limit: number;
-        readonly activation_usage: number;
-        readonly created_at: string;
-        readonly expires_at: string | null;
-    };
-    readonly instance: LemonSqueezyInstance;
-    readonly meta: LemonSqueezyMeta;
-}
-export interface LemonSqueezyDeactivateResponse {
-    readonly deactivated: boolean;
-    readonly error: string | null;
-}
-export interface ActivateLicenseInput {
-    readonly licenseKey: string;
-    readonly instanceName?: string;
-}
-export interface DeactivateLicenseInput {
-    readonly confirm: boolean;
-}
-export interface LicenseStatusInput {
-    readonly projectId?: string;
-}
-//# sourceMappingURL=licensing.d.ts.map

package/dist/types/licensing.js

@@ -1,4 +0,0 @@
-// types/licensing.ts — License management types for Planu SDD MCP Server.
-// Supports offline-first licensing via Lemon Squeezy as Merchant of Record.
-export {};
-//# sourceMappingURL=licensing.js.map