@shrkcrft/cli 0.1.0-alpha.2

package/dist/commands/plan-simulate.command.js

@@ -0,0 +1,60 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { inspectSharkcraft, renderPlanSimulationHtml, renderPlanSimulationMarkdown, renderPlanSimulationText, simulatePlan, } from '@shrkcrft/inspector';
+import { flagBool, flagNumber, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+export const planSimulateCommand = {
+    name: 'simulate',
+    description: 'Simulate a saved generation plan (v1 or v2): virtual final content, classified operations, boundary/policy/impact/test gates, apply readiness. Read-only.',
+    usage: 'shrk plan simulate <plan.json> [--format text|markdown|html|json] [--output <file>] [--strict] [--include-boundaries] [--include-impact] [--include-tests] [--include-policies] [--include-ownership] [--include-memory] [--diff] [--max-diff-lines N]',
+    async run(args) {
+        const planPath = args.positional[0];
+        if (!planPath) {
+            process.stderr.write('Usage: shrk plan simulate <plan.json>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const abs = nodePath.isAbsolute(planPath) ? planPath : nodePath.resolve(cwd, planPath);
+        let report;
+        try {
+            report = await simulatePlan(inspection, abs, {
+                strict: flagBool(args, 'strict'),
+                includeBoundaries: !flagBool(args, 'no-boundaries'),
+                includeImpact: !flagBool(args, 'no-impact'),
+                includeTests: !flagBool(args, 'no-tests'),
+                includePolicies: !flagBool(args, 'no-policies'),
+                includeOwnership: !flagBool(args, 'no-ownership'),
+                includeMemory: flagBool(args, 'include-memory'),
+                diff: flagBool(args, 'diff'),
+                ...(flagNumber(args, 'max-diff-lines') !== undefined
+                    ? { maxDiffLines: flagNumber(args, 'max-diff-lines') }
+                    : {}),
+            });
+        }
+        catch (e) {
+            process.stderr.write(`Failed to simulate plan: ${e.message}\n`);
+            return 1;
+        }
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        let body;
+        if (format === 'json' || flagBool(args, 'json'))
+            body = asJson(report) + '\n';
+        else if (format === 'markdown' || format === 'md')
+            body = renderPlanSimulationMarkdown(report);
+        else if (format === 'html')
+            body = renderPlanSimulationHtml(report);
+        else
+            body = renderPlanSimulationText(report);
+        const output = flagString(args, 'output');
+        if (output) {
+            const absOut = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+            mkdirSync(nodePath.dirname(absOut), { recursive: true });
+            writeFileSync(absOut, body, 'utf8');
+            process.stdout.write(`Wrote ${absOut}\n`);
+            return 0;
+        }
+        process.stdout.write(body);
+        return 0;
+    },
+};

package/dist/commands/plan.command.d.ts

@@ -0,0 +1,8 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const planReviewCommand: ICommandHandler;
+/**
+ * `shrk plan <subcommand>` parent — currently just exposes `review`. We avoid
+ * exposing destructive subcommands here; writes go through `shrk apply`.
+ */
+export declare const planParentCommand: ICommandHandler;
+//# sourceMappingURL=plan.command.d.ts.map

package/dist/commands/plan.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.command.d.ts","sourceRoot":"","sources":["../../src/commands/plan.command.ts"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC,eAAO,MAAM,iBAAiB,EAAE,eAkH/B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAqB/B,CAAC"}

package/dist/commands/plan.command.js

@@ -0,0 +1,139 @@
+import * as nodePath from 'node:path';
+import { buildApplyDispatchTrace, inspectSharkcraft, renderApplyDispatchTraceText, reviewSavedPlan, } from '@shrkcrft/inspector';
+import { readPlanFromFile } from '@shrkcrft/generator';
+import { flagBool, resolveCwd, } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+import { planSimulateCommand } from "./plan-simulate.command.js";
+export const planReviewCommand = {
+    name: 'review',
+    description: 'Inspect a saved generation plan (sharkcraft.plan/v1 JSON): files to create/update, signature status, related rules/paths, missing-tests heuristic, boundary risks, verification commands. Pass --trace-dispatch to include the apply dispatch trace. Read-only.',
+    usage: 'shrk plan review <plan.json> [--cwd <dir>] [--json] [--trace-dispatch]',
+    async run(args) {
+        const planPath = args.positional[0];
+        if (!planPath) {
+            process.stderr.write('Usage: shrk plan review <plan.json>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        let report;
+        try {
+            report = reviewSavedPlan(inspection, nodePath.resolve(planPath));
+        }
+        catch (e) {
+            process.stderr.write(`Failed to review plan: ${e.message}\n`);
+            return 1;
+        }
+        // Optional dispatch trace.
+        const wantTrace = flagBool(args, 'trace-dispatch');
+        let dispatchTrace = null;
+        if (wantTrace) {
+            const planResult = readPlanFromFile(nodePath.resolve(planPath));
+            if (planResult.ok) {
+                dispatchTrace = buildApplyDispatchTrace({
+                    plan: planResult.value,
+                    inspection,
+                    dryRun: false,
+                    verifySignature: true,
+                });
+            }
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ ...report, ...(dispatchTrace ? { dispatchTrace } : {}) }) + '\n');
+            return 0;
+        }
+        if (dispatchTrace) {
+            process.stdout.write(renderApplyDispatchTraceText(dispatchTrace));
+            process.stdout.write('\n');
+        }
+        process.stdout.write(header(`Plan review: ${planPath}`));
+        if (report.templateId)
+            process.stdout.write(kv('template', report.templateId) + '\n');
+        process.stdout.write(kv('signature', `${report.signature}${report.signatureMessage ? ' — ' + report.signatureMessage : ''}`) + '\n');
+        const createCount = report.files.filter((f) => f.type === 'create').length;
+        const updateCount = report.files.filter((f) => f.modifiesExisting === true).length;
+        const conflictCount = report.files.filter((f) => f.type === 'conflict').length;
+        process.stdout.write(kv('files', String(report.files.length)) + '\n');
+        process.stdout.write(kv('creates', String(createCount)) + '\n');
+        process.stdout.write(kv('modifies existing', String(updateCount)) + '\n');
+        if (conflictCount > 0)
+            process.stdout.write(kv('conflicts', String(conflictCount)) + '\n');
+        process.stdout.write('\n');
+        for (const f of report.files) {
+            const marker = f.modifiesExisting ? ' [modifies existing]' : '';
+            process.stdout.write(`  ${f.type.padEnd(14)} ${f.relativePath}${marker}${f.reason ? '  (' + f.reason + ')' : ''}\n`);
+        }
+        if (updateCount > 0) {
+            process.stdout.write(`\n  HUMAN REVIEW REQUIRED — ${updateCount} entry/entries modify existing files.\n`);
+        }
+        if (report.folderOps.length > 0) {
+            process.stdout.write('\nFolder operations:\n');
+            for (const op of report.folderOps) {
+                const head = op.kind === 'rename-folder' ? 'RENAME-FOLDER' : 'DELETE-FOLDER';
+                const arrow = op.newPath ? ` → ${op.newPath}` : '';
+                const safety = op.safety === 'safe' ? 'SAFE' : 'UNSAFE';
+                process.stdout.write(`  ${head} ${op.targetPath}${arrow}  [${safety}${op.safetyReason ? ` — ${op.safetyReason}` : ''}]  (requires --${op.requiresAllowFlag.replace('+', ' --')})\n`);
+            }
+            process.stdout.write(`\n  HUMAN REVIEW REQUIRED — folder ops mutate disk structure. They run only when --allow-folder-ops (and --allow-delete-folder for deletes) is passed.\n`);
+        }
+        if (report.affectedPaths.length) {
+            process.stdout.write('\nAffected path conventions:\n');
+            for (const p of report.affectedPaths)
+                process.stdout.write(`  • ${p}\n`);
+        }
+        if (report.missingTestsHeuristic.length) {
+            process.stdout.write('\nMissing tests heuristic:\n');
+            for (const m of report.missingTestsHeuristic)
+                process.stdout.write(`  • ${m}\n`);
+        }
+        if (report.potentialBoundaryConcerns.length) {
+            process.stdout.write('\nBoundary concerns (current state):\n');
+            for (const c of report.potentialBoundaryConcerns) {
+                process.stdout.write(`  ${c.severity.toUpperCase().padEnd(8)} ${c.file}:${c.line}  ${c.importSpecifier}  (${c.ruleId})\n`);
+            }
+        }
+        if (report.planIntroducedBoundaryConcerns.length) {
+            process.stdout.write('\nBoundary concerns introduced by this plan:\n');
+            for (const c of report.planIntroducedBoundaryConcerns) {
+                process.stdout.write(`  ${c.severity.toUpperCase().padEnd(8)} ${c.file}:${c.line}  ${c.importSpecifier}  (${c.ruleId})\n`);
+                if (c.resolvedVia)
+                    process.stdout.write(`           resolved via: ${c.resolvedVia}\n`);
+                if (c.suggestedFix)
+                    process.stdout.write(`           ↳ ${c.suggestedFix}\n`);
+            }
+        }
+        if (report.verificationCommands.length) {
+            process.stdout.write('\nVerification commands:\n');
+            for (const c of report.verificationCommands)
+                process.stdout.write(`  $ ${c}\n`);
+        }
+        process.stdout.write('\n' + report.humanApprovalReminder + '\n');
+        return 0;
+    },
+};
+/**
+ * `shrk plan <subcommand>` parent — currently just exposes `review`. We avoid
+ * exposing destructive subcommands here; writes go through `shrk apply`.
+ */
+export const planParentCommand = {
+    name: 'plan',
+    description: 'Inspect generation plans. Subcommand required.',
+    usage: 'shrk plan review|simulate <plan.json>',
+    async run(args) {
+        const sub = args.positional[0];
+        if (sub === 'review') {
+            return (await planReviewCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            }));
+        }
+        if (sub === 'simulate') {
+            return (await planSimulateCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            }));
+        }
+        process.stderr.write('Usage: shrk plan review|simulate <plan.json>\n');
+        return 2;
+    },
+};

package/dist/commands/playbooks.command.d.ts

@@ -0,0 +1,10 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const playbooksListCommand: ICommandHandler;
+export declare const playbooksGetCommand: ICommandHandler;
+export declare const playbooksRecommendCommand: ICommandHandler;
+export declare const playbooksRunbookCommand: ICommandHandler;
+export declare const playbooksBriefCommand: ICommandHandler;
+export declare const playbooksScriptCommand: ICommandHandler;
+export declare const playbooksPreviewCommand: ICommandHandler;
+export declare const playbooksValidateCommand: ICommandHandler;
+//# sourceMappingURL=playbooks.command.d.ts.map

package/dist/commands/playbooks.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playbooks.command.d.ts","sourceRoot":"","sources":["../../src/commands/playbooks.command.ts"],"names":[],"mappings":"AAaA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAahC,eAAO,MAAM,oBAAoB,EAAE,eAiBlC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eA4BjC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,eA4BvC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eA6CrC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eA6BnC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAoCpC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eA6CrC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAiCtC,CAAC"}

package/dist/commands/playbooks.command.js

@@ -0,0 +1,296 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildAgentBrief, buildPlaybookPreview, buildPlaybookScript, buildRunbook, inspectSharkcraft, loadPlaybooks, recommendPlaybooks, validatePlaybook, } from '@shrkcrft/inspector';
+import { flagBool, flagNumber, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+async function loadAll(args) {
+    const cwd = resolveCwd(args);
+    const inspection = await inspectSharkcraft({ cwd });
+    const playbooks = await loadPlaybooks(inspection);
+    return { playbooks, inspection };
+}
+export const playbooksListCommand = {
+    name: 'list',
+    description: 'List registered playbooks.',
+    usage: 'shrk playbooks list [--json]',
+    async run(args) {
+        const { playbooks } = await loadAll(args);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(playbooks) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Playbooks (${playbooks.length})`));
+        if (playbooks.length === 0)
+            process.stdout.write('  (none)\n');
+        for (const p of playbooks) {
+            process.stdout.write(`  ${p.id.padEnd(36)} ${p.title}\n`);
+        }
+        return 0;
+    },
+};
+export const playbooksGetCommand = {
+    name: 'get',
+    description: 'Show playbook details.',
+    usage: 'shrk playbooks get <id> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk playbooks get <id>\n');
+            return 2;
+        }
+        const { playbooks } = await loadAll(args);
+        const p = playbooks.find((x) => x.id === id);
+        if (!p) {
+            process.stderr.write(`No playbook "${id}"\n`);
+            return 1;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(p) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Playbook: ${p.id}`));
+        if (p.description)
+            process.stdout.write(`${p.description}\n\n`);
+        process.stdout.write(`Steps:\n`);
+        for (const s of p.steps) {
+            process.stdout.write(`  ${s.id}: ${s.title}\n`);
+        }
+        return 0;
+    },
+};
+export const playbooksRecommendCommand = {
+    name: 'recommend',
+    description: 'Recommend playbooks for a task.',
+    usage: 'shrk playbooks recommend "<task>" [--limit N] [--json]',
+    async run(args) {
+        const task = args.positional.join(' ').trim();
+        if (!task) {
+            process.stderr.write('Usage: shrk playbooks recommend "<task>"\n');
+            return 2;
+        }
+        const { playbooks } = await loadAll(args);
+        const recs = recommendPlaybooks(playbooks, task);
+        const limit = flagNumber(args, 'limit') ?? 5;
+        const top = recs.slice(0, limit);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(top) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Playbook recommendations for: ${task}`));
+        if (top.length === 0)
+            process.stdout.write('  (none matched)\n');
+        for (const r of top) {
+            process.stdout.write(`  ${String(r.score).padStart(4)}  ${r.playbook.id}  — ${r.playbook.title}\n`);
+            for (const why of r.reasons.slice(0, 3)) {
+                process.stdout.write(`        (${why})\n`);
+            }
+        }
+        return 0;
+    },
+};
+export const playbooksRunbookCommand = {
+    name: 'runbook',
+    description: 'Render a playbook as a structured human/agent runbook.',
+    usage: 'shrk playbooks runbook <id> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk playbooks runbook <id>\n');
+            return 2;
+        }
+        const { playbooks } = await loadAll(args);
+        const p = playbooks.find((x) => x.id === id);
+        if (!p) {
+            process.stderr.write(`No playbook "${id}"\n`);
+            return 1;
+        }
+        const rb = buildRunbook(p);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(rb) + '\n');
+            return 0;
+        }
+        process.stdout.write(`# Runbook: ${rb.title}\n\n`);
+        for (let i = 0; i < rb.steps.length; i += 1) {
+            const s = rb.steps[i];
+            process.stdout.write(`## Step ${i + 1}: ${s.title}\n`);
+            if (s.description)
+                process.stdout.write(`${s.description}\n`);
+            if (s.commands?.length) {
+                process.stdout.write('\nCommands:\n');
+                for (const c of s.commands)
+                    process.stdout.write(`  $ ${c}\n`);
+            }
+            if (s.verificationCommands?.length) {
+                process.stdout.write('\nVerify:\n');
+                for (const c of s.verificationCommands)
+                    process.stdout.write(`  ? ${c}\n`);
+            }
+            if (s.safetyNotes?.length) {
+                process.stdout.write('\nSafety:\n');
+                for (const c of s.safetyNotes)
+                    process.stdout.write(`  ! ${c}\n`);
+            }
+            if (s.humanReview) {
+                process.stdout.write('\n  (human review required before continuing)\n');
+            }
+            process.stdout.write('\n');
+        }
+        return 0;
+    },
+};
+export const playbooksBriefCommand = {
+    name: 'brief',
+    description: 'Render a playbook as an agent brief (Markdown).',
+    usage: 'shrk playbooks brief <id> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk playbooks brief <id>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const playbooks = await loadPlaybooks(inspection);
+        const p = playbooks.find((x) => x.id === id);
+        if (!p) {
+            process.stderr.write(`No playbook "${id}"\n`);
+            return 1;
+        }
+        const brief = await buildAgentBrief(inspection, { task: p.title });
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ playbook: p, brief }) + '\n');
+            return 0;
+        }
+        process.stdout.write(`# Playbook brief: ${p.title}\n\n`);
+        process.stdout.write(`Description: ${p.description ?? '(none)'}\n\n`);
+        process.stdout.write(`Steps: ${p.steps.length}\n\n`);
+        process.stdout.write(`---\n\n${brief.markdown}`);
+        return 0;
+    },
+};
+export const playbooksScriptCommand = {
+    name: 'script',
+    description: 'Render a playbook as a bash-like preview script (no execution).',
+    usage: 'shrk playbooks script <id> [--task "<task>"] [--output <path>] [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk playbooks script <id> [--task "<task>"] [--output <path>]\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const playbooks = await loadPlaybooks(inspection);
+        const p = playbooks.find((x) => x.id === id);
+        if (!p) {
+            process.stderr.write(`No playbook "${id}"\n`);
+            return 1;
+        }
+        const task = flagString(args, 'task');
+        const result = buildPlaybookScript(p, task ? { task } : {});
+        const output = flagString(args, 'output');
+        if (output) {
+            const abs = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+            mkdirSync(nodePath.dirname(abs), { recursive: true });
+            writeFileSync(abs, result.script, { mode: 0o755 });
+            if (flagBool(args, 'json'))
+                process.stdout.write(asJson({ wrote: abs, ...result }) + '\n');
+            else
+                process.stdout.write(`Wrote ${abs}\n`);
+            return 0;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(result) + '\n');
+            return 0;
+        }
+        process.stdout.write(result.script);
+        return 0;
+    },
+};
+export const playbooksPreviewCommand = {
+    name: 'preview',
+    description: 'Show a playbook preview (structured steps + recommendations).',
+    usage: 'shrk playbooks preview <id> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk playbooks preview <id>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const playbooks = await loadPlaybooks(inspection);
+        const p = playbooks.find((x) => x.id === id);
+        if (!p) {
+            process.stderr.write(`No playbook "${id}"\n`);
+            return 1;
+        }
+        const preview = buildPlaybookPreview(p);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(preview) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Playbook preview: ${preview.title}`));
+        if (preview.description)
+            process.stdout.write(`${preview.description}\n\n`);
+        for (let i = 0; i < preview.steps.length; i += 1) {
+            const s = preview.steps[i];
+            process.stdout.write(`Step ${i + 1}: ${s.title}${s.humanReview ? '  (human review)' : ''}\n`);
+            if (s.commands.length)
+                for (const c of s.commands)
+                    process.stdout.write(`  $ ${c}\n`);
+            if (s.mcpTools.length)
+                process.stdout.write(`  mcp: ${s.mcpTools.join(', ')}\n`);
+            if (s.verificationCommands.length) {
+                process.stdout.write(`  verify:\n`);
+                for (const v of s.verificationCommands)
+                    process.stdout.write(`    ? ${v}\n`);
+            }
+            if (s.safetyNotes.length) {
+                for (const n of s.safetyNotes)
+                    process.stdout.write(`  ! ${n}\n`);
+            }
+        }
+        if (preview.outputs.length > 0) {
+            process.stdout.write('\nOutputs:\n');
+            for (const o of preview.outputs)
+                process.stdout.write(`  - ${o}\n`);
+        }
+        return 0;
+    },
+};
+export const playbooksValidateCommand = {
+    name: 'validate',
+    description: 'Validate a playbook against the registered templates / pipelines.',
+    usage: 'shrk playbooks validate <id> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk playbooks validate <id>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const playbooks = await loadPlaybooks(inspection);
+        const p = playbooks.find((x) => x.id === id);
+        if (!p) {
+            process.stderr.write(`No playbook "${id}"\n`);
+            return 1;
+        }
+        const v = validatePlaybook(p, inspection);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(v) + '\n');
+            return v.passed ? 0 : 1;
+        }
+        process.stdout.write(header(`Playbook validate: ${id}`));
+        if (v.issues.length === 0) {
+            process.stdout.write('No issues.\n');
+            return 0;
+        }
+        for (const i of v.issues) {
+            process.stdout.write(`  ${i.severity.toUpperCase().padEnd(8)} ${i.code.padEnd(28)} ${i.message}\n`);
+        }
+        return v.passed ? 0 : 1;
+    },
+};
+void flagString;

package/dist/commands/plugin.command.d.ts

@@ -0,0 +1,11 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const pluginRenameCommand: ICommandHandler;
+export declare const pluginRemoveCommand: ICommandHandler;
+export declare const pluginLifecycleListCommand: ICommandHandler;
+export declare const pluginLifecycleInspectCommand: ICommandHandler;
+export declare const pluginLifecycleProfilesCommand: ICommandHandler;
+export declare const pluginLifecycleProfileCommand: ICommandHandler;
+export declare const pluginLifecycleDoctorCommand: ICommandHandler;
+export declare const pluginLifecycleCommand: ICommandHandler;
+export declare const pluginCommand: ICommandHandler;
+//# sourceMappingURL=plugin.command.d.ts.map

package/dist/commands/plugin.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.command.d.ts","sourceRoot":"","sources":["../../src/commands/plugin.command.ts"],"names":[],"mappings":"AA+BA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA2BhC,eAAO,MAAM,mBAAmB,EAAE,eAmEjC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAkEjC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAwBxC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAsC3C,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,eA4B5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAkD3C,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,eA0C1C,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAepC,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,eAc3B,CAAC"}