@thiagodiogo/pastelsdd 1.0.0-beta.1

package/dist/commands/context-store.js

@@ -0,0 +1,282 @@
+import { ContextStoreError, doctorContextStores, listContextStores, prepareContextStoreSetup, registerExistingContextStore, setupPreparedContextStore, } from '../core/context-store/index.js';
+import { isInteractive } from '../utils/interactive.js';
+function printJson(payload) {
+    console.log(JSON.stringify(payload, null, 2));
+}
+function asErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function appendStatus(payload, status) {
+    return {
+        ...payload,
+        status: [...payload.status, status],
+    };
+}
+function toStoreOutput(store) {
+    return {
+        id: store.id,
+        root: store.root,
+        ...(store.metadataPath ? { metadata_path: store.metadataPath } : {}),
+    };
+}
+function toMutationOutput(result) {
+    return {
+        context_store: toStoreOutput(result.store),
+        registry: {
+            path: result.registryCommit.path,
+            registered: true,
+        },
+        git: {
+            is_repository: result.git.isRepository,
+            initialized: result.git.initialized,
+        },
+        created_files: result.createdArtifacts,
+        status: [],
+    };
+}
+function toListOutput(result) {
+    return {
+        context_stores: result.stores.map(toStoreOutput),
+        status: [],
+    };
+}
+function toDoctorStoreOutput(store) {
+    return {
+        ...toStoreOutput(store),
+        metadata: store.metadata,
+        git: {
+            is_repository: store.git.isRepository,
+        },
+        status: store.diagnostics,
+    };
+}
+function toDoctorOutput(result) {
+    return {
+        context_stores: result.stores.map(toDoctorStoreOutput),
+        status: result.diagnostics,
+    };
+}
+function asStatus(error) {
+    if (error instanceof ContextStoreError) {
+        return error.diagnostic;
+    }
+    const message = asErrorMessage(error);
+    return {
+        severity: 'error',
+        code: 'context_store_error',
+        message,
+    };
+}
+function isPromptCancellationError(error) {
+    return (error instanceof Error &&
+        (error.name === 'ExitPromptError' || error.message.includes('force closed the prompt with SIGINT')));
+}
+async function shouldInitializeGit(options) {
+    if (options.initGit !== undefined) {
+        return options.initGit;
+    }
+    if (options.json || !isInteractive()) {
+        return false;
+    }
+    const { confirm } = await import('@inquirer/prompts');
+    return confirm({
+        message: 'Initialize Git repository?',
+        default: true,
+    });
+}
+function formatGitHuman(git) {
+    if (!git)
+        return 'unknown';
+    if (git.initialized)
+        return 'initialized';
+    return git.is_repository ? 'repository detected' : 'not initialized';
+}
+function printMutationHuman(title, payload) {
+    if (!payload.context_store || !payload.registry || !payload.git) {
+        return;
+    }
+    console.log(title);
+    console.log('');
+    console.log(`ID: ${payload.context_store.id}`);
+    console.log(`Location: ${payload.context_store.root}`);
+    console.log(`Metadata: ${payload.context_store.metadata_path}`);
+    console.log(`Registry: ${payload.registry.path}`);
+    console.log(`Git: ${formatGitHuman(payload.git)}`);
+}
+function printListHuman(payload) {
+    if (payload.context_stores.length === 0) {
+        console.log('No context stores registered.');
+        console.log('');
+        console.log('Next:');
+        console.log('  pastelsdd context-store setup team-context');
+        console.log('  pastelsdd context-store register /path/to/context-store');
+        return;
+    }
+    console.log(`Pastelsdd context stores (${payload.context_stores.length})`);
+    console.log('');
+    console.log(`${'ID'.padEnd(16)}Location`);
+    for (const store of payload.context_stores) {
+        console.log(`${store.id.padEnd(16)}${store.root}`);
+    }
+}
+function formatMetadataHuman(store) {
+    if (store.metadata.valid)
+        return 'ok';
+    if (store.metadata.present === false)
+        return 'missing';
+    if (store.metadata.present === null)
+        return 'unknown';
+    return 'invalid';
+}
+function formatDoctorGitHuman(store) {
+    if (store.git.is_repository === null)
+        return 'unknown';
+    return store.git.is_repository ? 'repository detected' : 'not detected';
+}
+function printDoctorHuman(payload) {
+    if (payload.context_stores.length === 0) {
+        console.log('No context stores registered.');
+        return;
+    }
+    console.log('Context store doctor');
+    for (const store of payload.context_stores) {
+        console.log('');
+        console.log(store.id);
+        console.log(`  Location: ${store.root}`);
+        console.log(`  Metadata: ${formatMetadataHuman(store)}`);
+        console.log(`  Git: ${formatDoctorGitHuman(store)}`);
+        if (store.status.length === 0) {
+            console.log('  Issues: none');
+            continue;
+        }
+        console.log('  Issues:');
+        for (const status of store.status) {
+            console.log(`    - ${status.message}`);
+            if (status.fix) {
+                console.log(`      Fix: ${status.fix}`);
+            }
+        }
+    }
+}
+class ContextStoreCommand {
+    async setup(id, options = {}) {
+        try {
+            const prepared = await prepareContextStoreSetup({
+                id,
+                path: options.path,
+            });
+            const initGit = await shouldInitializeGit(options);
+            const payload = toMutationOutput(await setupPreparedContextStore(prepared, {
+                initGit,
+            }));
+            if (options.json) {
+                printJson(payload);
+                return;
+            }
+            printMutationHuman('Context store setup complete', payload);
+        }
+        catch (error) {
+            this.handleFailure(options.json, { context_store: null, registry: null, git: null, created_files: [], status: [] }, error);
+        }
+    }
+    async register(inputPath, options = {}) {
+        try {
+            const payload = toMutationOutput(await registerExistingContextStore({
+                path: inputPath,
+                id: options.id,
+            }));
+            if (options.json) {
+                printJson(payload);
+                return;
+            }
+            printMutationHuman('Context store registered', payload);
+        }
+        catch (error) {
+            this.handleFailure(options.json, { context_store: null, registry: null, git: null, created_files: [], status: [] }, error);
+        }
+    }
+    async list(options = {}) {
+        try {
+            const payload = toListOutput(await listContextStores());
+            if (options.json) {
+                printJson(payload);
+                return;
+            }
+            printListHuman(payload);
+        }
+        catch (error) {
+            this.handleFailure(options.json, { context_stores: [], status: [] }, error);
+        }
+    }
+    async doctor(id, options = {}) {
+        try {
+            const payload = toDoctorOutput(await doctorContextStores(id));
+            if (options.json) {
+                printJson(payload);
+                return;
+            }
+            printDoctorHuman(payload);
+        }
+        catch (error) {
+            this.handleFailure(options.json, { context_stores: [], status: [] }, error);
+        }
+    }
+    handleFailure(json, payload, error) {
+        if (!json && isPromptCancellationError(error)) {
+            console.error('Cancelled.');
+            process.exitCode = 130;
+            return;
+        }
+        const status = asStatus(error);
+        if (json) {
+            printJson(appendStatus(payload, status));
+            process.exitCode = 1;
+            return;
+        }
+        console.error(`Error: ${status.message}`);
+        if (status.fix) {
+            console.error(`Fix: ${status.fix}`);
+        }
+        process.exitCode = 1;
+    }
+}
+export function registerContextStoreCommand(program) {
+    const contextStoreCommand = new ContextStoreCommand();
+    const contextStore = program
+        .command('context-store')
+        .description('Set up and inspect local context stores');
+    contextStore
+        .command('setup [id]')
+        .description('Create and register a local context store')
+        .option('--path <path>', 'Context store folder path; defaults to ./<id>')
+        .option('--init-git', 'Initialize a Git repository in the context store')
+        .option('--no-init-git', 'Do not initialize a Git repository')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        await contextStoreCommand.setup(id, options);
+    });
+    contextStore
+        .command('register [path]')
+        .description('Register an existing local context store')
+        .option('--id <id>', 'Context store id; defaults to metadata or folder name')
+        .option('--json', 'Output as JSON')
+        .action(async (inputPath, options) => {
+        await contextStoreCommand.register(inputPath, options);
+    });
+    contextStore
+        .command('list')
+        .alias('ls')
+        .description('List locally registered context stores')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        await contextStoreCommand.list(options);
+    });
+    contextStore
+        .command('doctor [id]')
+        .description('Check local context-store registration and metadata')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        await contextStoreCommand.doctor(id, options);
+    });
+}
+//# sourceMappingURL=context-store.js.map

package/dist/commands/feedback.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Feedback command implementation
+ */
+export declare class FeedbackCommand {
+    execute(message: string, options?: {
+        body?: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=feedback.d.ts.map

package/dist/commands/feedback.js

@@ -0,0 +1,183 @@
+import { execSync, execFileSync } from 'child_process';
+import { createRequire } from 'module';
+import os from 'os';
+const require = createRequire(import.meta.url);
+/**
+ * Check if gh CLI is installed and available in PATH
+ * Uses platform-appropriate command: 'where' on Windows, 'which' on Unix/macOS
+ */
+function isGhInstalled() {
+    try {
+        const command = process.platform === 'win32' ? 'where gh' : 'which gh';
+        execSync(command, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if gh CLI is authenticated
+ */
+function isGhAuthenticated() {
+    try {
+        execSync('gh auth status', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get Pastelsdd version from package.json
+ */
+function getVersion() {
+    try {
+        const { version } = require('../../package.json');
+        return version;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Get platform name
+ */
+function getPlatform() {
+    return os.platform();
+}
+/**
+ * Get current timestamp in ISO format
+ */
+function getTimestamp() {
+    return new Date().toISOString();
+}
+/**
+ * Generate metadata footer for feedback
+ */
+function generateMetadata() {
+    const version = getVersion();
+    const platform = getPlatform();
+    const timestamp = getTimestamp();
+    return `---
+Submitted via Pastelsdd CLI
+- Version: ${version}
+- Platform: ${platform}
+- Timestamp: ${timestamp}`;
+}
+/**
+ * Format the feedback title
+ */
+function formatTitle(message) {
+    return `Feedback: ${message}`;
+}
+/**
+ * Format the full feedback body
+ */
+function formatBody(bodyText) {
+    const parts = [];
+    if (bodyText) {
+        parts.push(bodyText);
+        parts.push(''); // Empty line before metadata
+    }
+    parts.push(generateMetadata());
+    return parts.join('\n');
+}
+/**
+ * Generate a pre-filled GitHub issue URL for manual submission
+ */
+function generateManualSubmissionUrl(title, body) {
+    const repo = 'thiagodiogo/Pastelsdd';
+    const encodedTitle = encodeURIComponent(title);
+    const encodedBody = encodeURIComponent(body);
+    const encodedLabels = encodeURIComponent('feedback');
+    return `https://github.com/${repo}/issues/new?title=${encodedTitle}&body=${encodedBody}&labels=${encodedLabels}`;
+}
+/**
+ * Display formatted feedback content for manual submission
+ */
+function displayFormattedFeedback(title, body) {
+    console.log('\n--- FORMATTED FEEDBACK ---');
+    console.log(`Title: ${title}`);
+    console.log(`Labels: feedback`);
+    console.log('\nBody:');
+    console.log(body);
+    console.log('--- END FEEDBACK ---\n');
+}
+/**
+ * Submit feedback via gh CLI
+ * Uses execFileSync to prevent shell injection vulnerabilities
+ */
+function submitViaGhCli(title, body) {
+    try {
+        const result = execFileSync('gh', [
+            'issue',
+            'create',
+            '--repo',
+            'thiagodiogo/Pastelsdd',
+            '--title',
+            title,
+            '--body',
+            body,
+            '--label',
+            'feedback',
+        ], { encoding: 'utf-8', stdio: 'pipe' });
+        const issueUrl = result.trim();
+        console.log(`\n✓ Feedback submitted successfully!`);
+        console.log(`Issue URL: ${issueUrl}\n`);
+    }
+    catch (error) {
+        // Display the error output from gh CLI
+        if (error.stderr) {
+            console.error(error.stderr.toString());
+        }
+        else if (error.message) {
+            console.error(error.message);
+        }
+        // Exit with the same code as gh CLI
+        process.exit(error.status ?? 1);
+    }
+}
+/**
+ * Handle fallback when gh CLI is not available or not authenticated
+ */
+function handleFallback(title, body, reason) {
+    if (reason === 'missing') {
+        console.log('⚠️  GitHub CLI not found. Manual submission required.');
+    }
+    else {
+        console.log('⚠️  GitHub authentication required. Manual submission required.');
+    }
+    displayFormattedFeedback(title, body);
+    const manualUrl = generateManualSubmissionUrl(title, body);
+    console.log('Please submit your feedback manually:');
+    console.log(manualUrl);
+    if (reason === 'unauthenticated') {
+        console.log('\nTo auto-submit in the future: gh auth login');
+    }
+    // Exit with success code (fallback is successful)
+    process.exit(0);
+}
+/**
+ * Feedback command implementation
+ */
+export class FeedbackCommand {
+    async execute(message, options) {
+        // Format title and body once for all code paths
+        const title = formatTitle(message);
+        const body = formatBody(options?.body);
+        // Check if gh CLI is installed
+        if (!isGhInstalled()) {
+            handleFallback(title, body, 'missing');
+            return;
+        }
+        // Check if gh CLI is authenticated
+        if (!isGhAuthenticated()) {
+            handleFallback(title, body, 'unauthenticated');
+            return;
+        }
+        // Submit via gh CLI
+        submitViaGhCli(title, body);
+    }
+}
+//# sourceMappingURL=feedback.js.map

package/dist/commands/initiative.d.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import { type InitiativeResolutionDetails, type InitiativeDiagnostic } from '../core/collections/initiatives/index.js';
+export declare class InitiativeCliError extends Error {
+    readonly diagnostic: InitiativeDiagnostic;
+    constructor(message: string, code: string, options?: {
+        target?: string;
+        fix?: string;
+        details?: InitiativeResolutionDetails;
+    });
+}
+export declare function initiativeDiagnosticFromError(error: unknown): InitiativeDiagnostic;
+export declare function registerInitiativeCommand(program: Command): void;
+//# sourceMappingURL=initiative.d.ts.map