@nitrostack/cli 1.0.13 → 1.0.15

package/dist/pack/gitignore.js

@@ -0,0 +1,123 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { loadCanonicalGitignore } from './canonical-gitignore.js';
+import { ENV_EXCLUDED_PATTERNS, HARD_EXCLUDED_PATTERNS } from './exclusions.js';
+import { createIgnoreMatcher } from './ignore-matcher.js';
+const GIT_DIR_PATTERN = '.git/';
+function normalizeRuleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+        return null;
+    }
+    return trimmed;
+}
+function parseRules(content) {
+    return content
+        .split(/\r?\n/)
+        .map(normalizeRuleLine)
+        .filter((line) => line !== null);
+}
+function isEnvRule(rule) {
+    return ENV_EXCLUDED_PATTERNS.some((pattern) => {
+        if (pattern === rule)
+            return true;
+        if (pattern === '.env.*.local') {
+            return /^\.env\..+\.local$/.test(rule) || rule === '.env.*.local';
+        }
+        return rule === pattern || rule.startsWith(`${pattern}/`);
+    }) || rule === '.env' || rule.startsWith('.env.');
+}
+/**
+ * Non-destructively merge canonical rules into a local .gitignore.
+ * Existing local rules are preserved; only missing canonical rules are appended.
+ */
+export function mergeGitignoreRules(localContent, canonicalContent) {
+    const localRules = parseRules(localContent);
+    const canonicalRules = parseRules(canonicalContent);
+    const existing = new Set(localRules);
+    const addedRules = [];
+    for (const rule of canonicalRules) {
+        if (!existing.has(rule)) {
+            addedRules.push(rule);
+            existing.add(rule);
+        }
+    }
+    if (!existing.has(GIT_DIR_PATTERN)) {
+        addedRules.push(GIT_DIR_PATTERN);
+        existing.add(GIT_DIR_PATTERN);
+    }
+    const newlyAddedRules = addedRules.filter((rule) => !localRules.includes(rule));
+    const updated = newlyAddedRules.length > 0;
+    if (!updated) {
+        const normalized = localContent.endsWith('\n') || localContent.length === 0
+            ? localContent
+            : `${localContent}\n`;
+        return {
+            mergedContent: normalized,
+            addedRules: [],
+            updated: false,
+        };
+    }
+    const mergedContent = rebuildGitignoreContent(localContent, newlyAddedRules);
+    return {
+        mergedContent,
+        addedRules: newlyAddedRules,
+        updated: true,
+    };
+}
+function rebuildGitignoreContent(localContent, appendedRules) {
+    const base = localContent.trimEnd();
+    const suffix = appendedRules.join('\n');
+    return base.length > 0 ? `${base}\n\n# Added by nitrostack pack\n${suffix}\n` : `${suffix}\n`;
+}
+/**
+ * Sync local .gitignore with canonical rules when enabled.
+ */
+export async function syncProjectGitignore(projectRoot, syncGitignore) {
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    const canonicalContent = await loadCanonicalGitignore();
+    const localContent = (await fs.pathExists(gitignorePath))
+        ? await fs.readFile(gitignorePath, 'utf-8')
+        : '';
+    const mergeResult = mergeGitignoreRules(localContent, canonicalContent);
+    if (syncGitignore && mergeResult.updated) {
+        await fs.writeFile(gitignorePath, mergeResult.mergedContent, 'utf-8');
+        return mergeResult;
+    }
+    // Matcher still uses merged rules, but only report an update when we actually wrote.
+    return {
+        mergedContent: mergeResult.mergedContent,
+        addedRules: [],
+        updated: false,
+    };
+}
+/**
+ * Build a gitignore matcher from merged project rules and hard-coded exclusions.
+ */
+export function buildIgnoreMatcher(mergedGitignoreContent, options = {}) {
+    const includeEnv = options.includeEnv ?? false;
+    let mergedRules = parseRules(mergedGitignoreContent);
+    if (includeEnv) {
+        mergedRules = mergedRules.filter((rule) => !isEnvRule(rule));
+    }
+    const hardPatterns = includeEnv
+        ? HARD_EXCLUDED_PATTERNS.filter((pattern) => !ENV_EXCLUDED_PATTERNS.includes(pattern))
+        : HARD_EXCLUDED_PATTERNS;
+    const allRules = [...mergedRules];
+    for (const pattern of hardPatterns) {
+        if (!allRules.includes(pattern)) {
+            allRules.push(pattern);
+        }
+    }
+    if (!allRules.includes(GIT_DIR_PATTERN)) {
+        allRules.push(GIT_DIR_PATTERN);
+    }
+    return createIgnoreMatcher(allRules);
+}
+export function isPathIgnored(matcher, projectRoot, absolutePath, isDirectory = false) {
+    const relativePath = path.relative(projectRoot, absolutePath).split(path.sep).join('/');
+    if (!relativePath || relativePath === '.') {
+        return false;
+    }
+    return matcher.ignores(relativePath, isDirectory);
+}

package/dist/pack/ignore-matcher.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Lightweight gitignore-style matcher implemented in-house (no external ignore package).
+ * Supports the pattern subset used by nitrostack pack:
+ * - Directory rules: dist/, .git/
+ * - Recursive directory rules: slash-star-star/dist/
+ * - Exact file names: .env, .DS_Store
+ * - Simple globs: *.log, *.tsbuildinfo, npm-debug.log*, .env.*.local
+ * - Path-anchored rules with / (match relative to project root)
+ * - Negation with leading ! (last matching rule wins)
+ */
+export interface IgnoreMatcher {
+    ignores(relativePath: string, isDirectory?: boolean): boolean;
+    add(patterns: string | string[]): IgnoreMatcher;
+}
+/**
+ * Create a matcher from a list of gitignore-style patterns.
+ */
+export declare function createIgnoreMatcher(patterns?: string[]): IgnoreMatcher;
+//# sourceMappingURL=ignore-matcher.d.ts.map

package/dist/pack/ignore-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore-matcher.d.ts","sourceRoot":"","sources":["../../src/pack/ignore-matcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAC9D,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,CAAC;CACjD;AAkHD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,GAAE,MAAM,EAAO,GAAG,aAAa,CAmD1E"}

package/dist/pack/ignore-matcher.js

@@ -0,0 +1,149 @@
+/**
+ * Lightweight gitignore-style matcher implemented in-house (no external ignore package).
+ * Supports the pattern subset used by nitrostack pack:
+ * - Directory rules: dist/, .git/
+ * - Recursive directory rules: slash-star-star/dist/
+ * - Exact file names: .env, .DS_Store
+ * - Simple globs: *.log, *.tsbuildinfo, npm-debug.log*, .env.*.local
+ * - Path-anchored rules with / (match relative to project root)
+ * - Negation with leading ! (last matching rule wins)
+ */
+function escapeRegex(value) {
+    return value.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Convert a single gitignore-like pattern into a RegExp that matches
+ * the full relative path (forward-slash separated, no leading ./).
+ */
+function compilePattern(pattern) {
+    let raw = pattern.trim();
+    if (!raw || raw.startsWith('#')) {
+        return null;
+    }
+    let negated = false;
+    if (raw.startsWith('!')) {
+        negated = true;
+        raw = raw.slice(1);
+    }
+    if (raw.startsWith('\\!')) {
+        raw = raw.slice(1);
+    }
+    let directoryOnly = false;
+    if (raw.endsWith('/')) {
+        directoryOnly = true;
+        raw = raw.slice(0, -1);
+    }
+    if (!raw) {
+        return null;
+    }
+    const anchored = raw.startsWith('/');
+    if (anchored) {
+        raw = raw.slice(1);
+    }
+    const hasSlash = raw.includes('/');
+    const isRecursivePrefix = raw.startsWith('**/');
+    const basenameOnly = !anchored && !hasSlash;
+    let body = '';
+    let i = 0;
+    while (i < raw.length) {
+        if (raw.startsWith('**/', i)) {
+            body += '(?:.*/)?';
+            i += 3;
+            continue;
+        }
+        if (raw[i] === '*') {
+            body += '[^/]*';
+            i += 1;
+            continue;
+        }
+        if (raw[i] === '?') {
+            body += '[^/]';
+            i += 1;
+            continue;
+        }
+        body += escapeRegex(raw[i]);
+        i += 1;
+    }
+    let source;
+    if (isRecursivePrefix || raw.includes('**/')) {
+        source = `^${body}(?:/.*)?$`;
+    }
+    else if (basenameOnly) {
+        // Match the basename anywhere in the path (gitignore default)
+        source = `(^|/)${body}(?:/.*)?$`;
+    }
+    else if (anchored || hasSlash) {
+        source = `^${body}(?:/.*)?$`;
+    }
+    else {
+        source = `(^|/)${body}(?:/.*)?$`;
+    }
+    // For directory-only rules, also compile a regex that requires a child path
+    // so a plain file named "dist" is not treated like directory "dist/".
+    let underSource;
+    if (isRecursivePrefix || raw.includes('**/')) {
+        underSource = `^${body}/.+$`;
+    }
+    else if (basenameOnly) {
+        underSource = `(^|/)${body}/.+$`;
+    }
+    else {
+        underSource = `^${body}/.+$`;
+    }
+    return {
+        raw: pattern.trim(),
+        negated,
+        directoryOnly,
+        anchored,
+        regex: new RegExp(source),
+        underRegex: directoryOnly ? new RegExp(underSource) : null,
+    };
+}
+function normalizeRelativePath(relativePath) {
+    return relativePath.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+}
+/**
+ * Create a matcher from a list of gitignore-style patterns.
+ */
+export function createIgnoreMatcher(patterns = []) {
+    const rules = [];
+    const matcher = {
+        add(input) {
+            const list = Array.isArray(input) ? input : [input];
+            for (const pattern of list) {
+                const compiled = compilePattern(pattern);
+                if (compiled) {
+                    rules.push(compiled);
+                }
+            }
+            return matcher;
+        },
+        ignores(relativePath, isDirectory = false) {
+            const normalized = normalizeRelativePath(relativePath);
+            if (!normalized || normalized === '.') {
+                return false;
+            }
+            // Trailing slash is a directory hint (gitignore-style)
+            const asDirectory = isDirectory || relativePath.replace(/\\/g, '/').endsWith('/');
+            let ignored = false;
+            for (const rule of rules) {
+                if (!rule.regex.test(normalized)) {
+                    continue;
+                }
+                if (rule.directoryOnly && !asDirectory) {
+                    // Plain file: only ignore if it lives under the directory, not if it
+                    // merely shares the directory's name (e.g. file "dist" vs dir "dist/").
+                    if (!rule.underRegex || !rule.underRegex.test(normalized)) {
+                        continue;
+                    }
+                }
+                ignored = !rule.negated;
+            }
+            return ignored;
+        },
+    };
+    if (patterns.length > 0) {
+        matcher.add(patterns);
+    }
+    return matcher;
+}

package/dist/pack/index.d.ts

@@ -0,0 +1,11 @@
+export { createIgnoreMatcher } from './ignore-matcher.js';
+export type { IgnoreMatcher } from './ignore-matcher.js';
+export { mergeGitignoreRules, buildIgnoreMatcher, syncProjectGitignore, isPathIgnored, } from './gitignore.js';
+export { loadCanonicalGitignore, getCanonicalGitignorePath, writeCanonicalGitignore } from './canonical-gitignore.js';
+export { getExclusionReport, HARD_EXCLUDED_PATTERNS, ENV_EXCLUDED_PATTERNS, EXCLUSION_CATEGORIES, } from './exclusions.js';
+export { collectFilesToPack, createOptimizedZip } from './zipper.js';
+export { formatPackTree } from './tree.js';
+export { packProject } from './pack-project.js';
+export { validateNitrostackProject, PackValidationError } from './validate-project.js';
+export type { PackOptions, PackResult, ExclusionCategory, NitrostackProjectInfo, GitignoreMergeResult, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/pack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pack/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACtH,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvF,YAAY,EACV,WAAW,EACX,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,YAAY,CAAC"}

package/dist/pack/index.js

@@ -0,0 +1,8 @@
+export { createIgnoreMatcher } from './ignore-matcher.js';
+export { mergeGitignoreRules, buildIgnoreMatcher, syncProjectGitignore, isPathIgnored, } from './gitignore.js';
+export { loadCanonicalGitignore, getCanonicalGitignorePath, writeCanonicalGitignore } from './canonical-gitignore.js';
+export { getExclusionReport, HARD_EXCLUDED_PATTERNS, ENV_EXCLUDED_PATTERNS, EXCLUSION_CATEGORIES, } from './exclusions.js';
+export { collectFilesToPack, createOptimizedZip } from './zipper.js';
+export { formatPackTree } from './tree.js';
+export { packProject } from './pack-project.js';
+export { validateNitrostackProject, PackValidationError } from './validate-project.js';

package/dist/pack/pack-project.d.ts

@@ -0,0 +1,6 @@
+import type { PackOptions, PackResult } from './types.js';
+/**
+ * Pack a NitroStack project into an optimized zip archive.
+ */
+export declare function packProject(options?: PackOptions): Promise<PackResult>;
+//# sourceMappingURL=pack-project.d.ts.map

package/dist/pack/pack-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-project.d.ts","sourceRoot":"","sources":["../../src/pack/pack-project.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAqB1D;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CA2ChF"}

package/dist/pack/pack-project.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import { getExclusionReport } from './exclusions.js';
+import { buildIgnoreMatcher, syncProjectGitignore } from './gitignore.js';
+import { formatPackTree } from './tree.js';
+import { validateNitrostackProject } from './validate-project.js';
+import { collectFilesToPack, createOptimizedZip, getZipSizeBytes } from './zipper.js';
+function sanitizeZipName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'nitrostack-project';
+}
+/**
+ * Always place the zip in the project root.
+ * If --output is provided, only the filename is used (directories / absolute paths are ignored).
+ */
+function resolveOutputPath(projectRoot, projectName, output) {
+    const rawName = output
+        ? path.basename(output).replace(/\.zip$/i, '') || projectName
+        : projectName;
+    const fileName = sanitizeZipName(rawName);
+    return path.join(projectRoot, `${fileName}.zip`);
+}
+/**
+ * Pack a NitroStack project into an optimized zip archive.
+ */
+export async function packProject(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const syncGitignore = options.syncGitignore ?? true;
+    const dryRun = options.dryRun ?? false;
+    const includeEnv = options.includeEnv ?? false;
+    const project = await validateNitrostackProject(cwd);
+    const mergeResult = await syncProjectGitignore(project.projectRoot, syncGitignore);
+    const matcher = buildIgnoreMatcher(mergeResult.mergedContent, { includeEnv });
+    const outputPath = resolveOutputPath(project.projectRoot, project.projectName, options.output);
+    if (dryRun) {
+        const collection = await collectFilesToPack(project.projectRoot, matcher);
+        return {
+            outputPath: null,
+            projectName: project.projectName,
+            filesIncluded: collection.filesIncluded,
+            zipSizeBytes: null,
+            gitignoreUpdated: mergeResult.updated,
+            addedGitignoreRules: mergeResult.addedRules,
+            excludedCategories: getExclusionReport(includeEnv),
+            includedPaths: collection.includedPaths,
+            excludedPaths: collection.excludedPaths,
+            dryRunTree: formatPackTree(project.projectName, collection.includedPaths, collection.excludedPaths),
+        };
+    }
+    const collection = await createOptimizedZip(project.projectRoot, outputPath, matcher);
+    const zipSizeBytes = await getZipSizeBytes(outputPath);
+    return {
+        outputPath,
+        projectName: project.projectName,
+        filesIncluded: collection.filesIncluded,
+        zipSizeBytes,
+        gitignoreUpdated: mergeResult.updated,
+        addedGitignoreRules: mergeResult.addedRules,
+        excludedCategories: getExclusionReport(includeEnv),
+    };
+}

package/dist/pack/standalone.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function runStandalonePack(argv?: string[]): Promise<void>;
+//# sourceMappingURL=standalone.d.ts.map

package/dist/pack/standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../../src/pack/standalone.ts"],"names":[],"mappings":";AAuDA,wBAAsB,iBAAiB,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwCpF"}

package/dist/pack/standalone.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+import { realpathSync } from 'fs';
+import { packProject } from './pack-project.js';
+import { PackValidationError } from './validate-project.js';
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function printExclusionReport(result) {
+    console.log(chalk.bold('\nExcluded from zip:'));
+    for (const category of result.excludedCategories) {
+        console.log(`  ${chalk.cyan(category.category)}: ${category.paths.join(', ')}`);
+    }
+}
+function printDryRunTree(result) {
+    if (!result.dryRunTree)
+        return;
+    console.log(chalk.bold('\nFile tree:'));
+    console.log(result.dryRunTree);
+}
+function printPackSummary(result, dryRun) {
+    if (result.gitignoreUpdated) {
+        console.log(chalk.green(`Updated .gitignore with ${result.addedGitignoreRules.length} rule(s).`));
+    }
+    printExclusionReport(result);
+    if (dryRun) {
+        printDryRunTree(result);
+    }
+    console.log(chalk.bold('\nPack summary:'));
+    console.log(`  Project: ${result.projectName}`);
+    console.log(`  Files included: ${result.filesIncluded}`);
+    if (result.outputPath) {
+        console.log(`  Output: ${result.outputPath}`);
+    }
+    if (result.zipSizeBytes !== null) {
+        console.log(`  Zip size: ${formatBytes(result.zipSizeBytes)}`);
+    }
+    else {
+        console.log('  Dry run: zip file was not created.');
+    }
+}
+export async function runStandalonePack(argv = process.argv) {
+    const program = new Command();
+    program
+        .name('nitrostack-pack')
+        .description('Create an optimized zip of a NitroStack project')
+        .option('-o, --output <path>', 'Zip filename (always written to the project root)')
+        .option('--dry-run', 'Show excluded/included summary without creating zip')
+        .option('--include-env', 'Include .env files in the zip')
+        .option('--no-sync-gitignore', 'Skip merging canonical rules into local .gitignore')
+        .option('--cwd <dir>', 'Project directory', process.cwd())
+        .action(async (options) => {
+        const packOptions = {
+            output: options.output,
+            dryRun: options.dryRun,
+            includeEnv: options.includeEnv ?? false,
+            syncGitignore: options.syncGitignore,
+            cwd: path.resolve(options.cwd),
+        };
+        try {
+            const result = await packProject(packOptions);
+            printPackSummary(result, Boolean(packOptions.dryRun));
+        }
+        catch (error) {
+            if (error instanceof PackValidationError) {
+                console.error(chalk.red(`Error: ${error.message}`));
+                process.exitCode = 1;
+                return;
+            }
+            throw error;
+        }
+    });
+    await program.parseAsync(argv);
+}
+function isMainModule() {
+    try {
+        const argvPath = realpathSync(process.argv[1]);
+        const modulePath = realpathSync(fileURLToPath(import.meta.url));
+        return argvPath === modulePath;
+    }
+    catch {
+        return process.argv[1]?.includes('standalone.js')
+            || process.argv[1]?.endsWith('nitrostack-pack');
+    }
+}
+if (isMainModule()) {
+    void runStandalonePack();
+}

package/dist/pack/tree.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Build an ASCII tree with ✅ (included) and ❌ (excluded) markers.
+ */
+export declare function formatPackTree(projectName: string, includedPaths: string[], excludedPaths: string[]): string;
+//# sourceMappingURL=tree.d.ts.map

package/dist/pack/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../src/pack/tree.ts"],"names":[],"mappings":"AAgEA;;GAEG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,EAAE,MAAM,EAAE,GACtB,MAAM,CAwBR"}

package/dist/pack/tree.js

@@ -0,0 +1,70 @@
+function ensureChild(parent, name, status) {
+    const existing = parent.children.get(name);
+    if (existing) {
+        // Prefer leaf status over container when the same name appears
+        if (existing.status === 'container' && status !== 'container') {
+            existing.status = status;
+        }
+        return existing;
+    }
+    const node = {
+        name,
+        status,
+        children: new Map(),
+    };
+    parent.children.set(name, node);
+    return node;
+}
+function insertPath(root, relativePath, status) {
+    const normalized = relativePath.replace(/\/+$/, '');
+    if (!normalized)
+        return;
+    const parts = normalized.split('/').filter(Boolean);
+    let current = root;
+    for (let i = 0; i < parts.length; i++) {
+        const isLeaf = i === parts.length - 1;
+        const partName = isLeaf && relativePath.endsWith('/') ? `${parts[i]}/` : parts[i];
+        const nodeStatus = isLeaf ? status : 'container';
+        current = ensureChild(current, partName, nodeStatus);
+    }
+}
+function statusSymbol(status) {
+    if (status === 'included')
+        return '✅';
+    if (status === 'excluded')
+        return '❌';
+    return '';
+}
+function renderNode(node, prefix, isLast, lines) {
+    const branch = isLast ? '└── ' : '├── ';
+    const symbol = statusSymbol(node.status);
+    const label = symbol ? `${node.name.padEnd(32)} ${symbol}` : node.name;
+    lines.push(`${prefix}${branch}${label}`);
+    const children = Array.from(node.children.values()).sort((a, b) => a.name.localeCompare(b.name));
+    const childPrefix = prefix + (isLast ? '    ' : '│   ');
+    children.forEach((child, index) => {
+        renderNode(child, childPrefix, index === children.length - 1, lines);
+    });
+}
+/**
+ * Build an ASCII tree with ✅ (included) and ❌ (excluded) markers.
+ */
+export function formatPackTree(projectName, includedPaths, excludedPaths) {
+    const root = {
+        name: `${projectName}/`,
+        status: 'container',
+        children: new Map(),
+    };
+    for (const included of includedPaths) {
+        insertPath(root, included, 'included');
+    }
+    for (const excluded of excludedPaths) {
+        insertPath(root, excluded, 'excluded');
+    }
+    const lines = [root.name];
+    const children = Array.from(root.children.values()).sort((a, b) => a.name.localeCompare(b.name));
+    children.forEach((child, index) => {
+        renderNode(child, '', index === children.length - 1, lines);
+    });
+    return lines.join('\n');
+}

package/dist/pack/types.d.ts

@@ -0,0 +1,35 @@
+export interface PackOptions {
+    output?: string;
+    dryRun?: boolean;
+    syncGitignore?: boolean;
+    includeEnv?: boolean;
+    cwd?: string;
+}
+export interface PackResult {
+    outputPath: string | null;
+    projectName: string;
+    filesIncluded: number;
+    zipSizeBytes: number | null;
+    gitignoreUpdated: boolean;
+    addedGitignoreRules: string[];
+    excludedCategories: ExclusionCategory[];
+    includedPaths?: string[];
+    excludedPaths?: string[];
+    dryRunTree?: string;
+}
+export interface ExclusionCategory {
+    category: string;
+    paths: string[];
+}
+export interface NitrostackProjectInfo {
+    projectRoot: string;
+    packageJsonPath: string;
+    projectName: string;
+    nitrostackPackages: string[];
+}
+export interface GitignoreMergeResult {
+    mergedContent: string;
+    addedRules: string[];
+    updated: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/pack/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/pack/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;IACxC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB"}

package/dist/pack/types.js

@@ -0,0 +1 @@
+export {};

package/dist/pack/validate-project.d.ts

@@ -0,0 +1,9 @@
+import type { NitrostackProjectInfo } from './types.js';
+export declare class PackValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validate that the target directory is a NitroStack project.
+ */
+export declare function validateNitrostackProject(cwd?: string): Promise<NitrostackProjectInfo>;
+//# sourceMappingURL=validate-project.d.ts.map

package/dist/pack/validate-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-project.d.ts","sourceRoot":"","sources":["../../src/pack/validate-project.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAQxD,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAkBD;;GAEG;AACH,wBAAsB,yBAAyB,CAC7C,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,qBAAqB,CAAC,CAyBhC"}