@nitrostack/cli 1.0.14 → 1.0.15

package/assets/canonical.gitignore

@@ -0,0 +1,57 @@
+# Dependencies
+node_modules/
+src/widgets/node_modules/
+
+# Build outputs
+dist/
+src/widgets/.next/
+src/widgets/out/
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids/
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage
+coverage/
+.nyc_output/
+
+# Uploads
+uploads/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache
+.npm/
+
+# Optional eslint cache
+.eslintcache
+
+# OAuth tokens/secrets (never commit these!)
+*.pem
+*.key
+tokens.json

package/dist/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AA4IA,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,WAAW,iBAmPtF"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AA6IA,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,WAAW,iBA2PtF"}

package/dist/commands/init.js

@@ -8,6 +8,7 @@ import { execSync } from 'child_process';
 import { NITRO_BANNER_FULL, createSuccessBox, NitroSpinner, log, spacer, nextSteps, brand, showFooter } from '../ui/branding.js';
 import { trackEvent, shutdownAnalytics } from '../analytics/posthog.js';
 import { runSkillsFlow } from '../skills/index.js';
+import { writeCanonicalGitignore } from '../pack/canonical-gitignore.js';
 import readline from 'readline';
 /**
  * Prompts the user with a horizontal YES/NO choice using left/right arrow keys.
@@ -201,6 +202,11 @@ export async function initCommand(projectName, options) {
         // Copy template files
         if (fs.existsSync(templateDir)) {
             fs.copySync(templateDir, targetDir);
+            // Template ships `_gitignore` (npm never packs files named `.gitignore`)
+            const placeholder = path.join(targetDir, '_gitignore');
+            if (fs.existsSync(placeholder)) {
+                fs.removeSync(placeholder);
+            }
         }
         else {
             await createProjectFromScratch(targetDir, finalProjectName, {
@@ -209,6 +215,8 @@ export async function initCommand(projectName, options) {
                 author: finalAuthor,
             });
         }
+        // Always write canonical .gitignore — npm strips `.gitignore` from published templates
+        await writeCanonicalGitignore(targetDir);
         // Update package.json
         const packageJsonPath = path.join(targetDir, 'package.json');
         if (fs.existsSync(packageJsonPath)) {
@@ -395,13 +403,6 @@ server.start().catch((error) => {
 `;
     fs.writeFileSync(path.join(targetDir, 'src', 'index.ts'), indexTs);
     fs.writeFileSync(path.join(targetDir, '.env'), '# Environment variables\n');
-    const gitignore = `node_modules/
-dist/
-.env
-.env.local
-*.log
-`;
-    fs.writeFileSync(path.join(targetDir, '.gitignore'), gitignore);
     const readme = `# ${projectName}
 
 ${answers.description}

package/dist/commands/pack.d.ts

@@ -0,0 +1,10 @@
+interface PackCommandOptions {
+    output?: string;
+    dryRun?: boolean;
+    syncGitignore?: boolean;
+    includeEnv?: boolean;
+    cwd?: string;
+}
+export declare function packCommand(options: PackCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=pack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pack.d.ts","sourceRoot":"","sources":["../../src/commands/pack.ts"],"names":[],"mappings":"AAiBA,UAAU,kBAAkB;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;AA2CD,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2D5E"}

package/dist/commands/pack.js

@@ -0,0 +1,82 @@
+import chalk from 'chalk';
+import path from 'path';
+import { createHeader, createSuccessBox, createErrorBox, NitroSpinner, spacer, brand, NITRO_BANNER_FULL, showFooter, } from '../ui/branding.js';
+import { trackEvent, shutdownAnalytics } from '../analytics/posthog.js';
+import { packProject } from '../pack/pack-project.js';
+import { PackValidationError } from '../pack/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 buildSummaryItems(result) {
+    const items = [
+        `${brand.skyBold(String(result.filesIncluded))} file(s) included`,
+    ];
+    if (result.outputPath) {
+        items.push(`Output: ${brand.sky(result.outputPath)}`);
+    }
+    if (result.zipSizeBytes !== null) {
+        items.push(`Size: ${brand.skyBold(formatBytes(result.zipSizeBytes))}`);
+    }
+    if (result.gitignoreUpdated) {
+        items.push(`Added ${result.addedGitignoreRules.length} .gitignore rule(s)`);
+    }
+    return items;
+}
+function printExcludedCategories(result) {
+    console.log(chalk.bold('\nExcluded from zip:'));
+    for (const category of result.excludedCategories) {
+        console.log(`  ${chalk.cyan(category.category)}: ${category.paths.join(', ')}`);
+    }
+    spacer();
+}
+function printDryRunTree(result) {
+    if (!result.dryRunTree)
+        return;
+    console.log(chalk.bold('File tree:'));
+    console.log(result.dryRunTree);
+    spacer();
+}
+export async function packCommand(options) {
+    console.log(NITRO_BANNER_FULL);
+    console.log(createHeader('Pack', 'Create optimized project archive'));
+    trackEvent('cli_command_invoked', {
+        command: 'pack',
+        options: Object.keys(options).filter((key) => options[key] !== undefined),
+    });
+    const packOptions = {
+        output: options.output,
+        dryRun: options.dryRun,
+        syncGitignore: options.syncGitignore ?? true,
+        includeEnv: options.includeEnv ?? false,
+        cwd: path.resolve(options.cwd ?? process.cwd()),
+    };
+    const spinner = new NitroSpinner(packOptions.dryRun ? 'Analyzing project files...' : 'Creating optimized zip...').start();
+    try {
+        const result = await packProject(packOptions);
+        spinner.succeed(packOptions.dryRun
+            ? 'Dry run complete'
+            : `Created ${path.basename(result.outputPath ?? 'archive')}`);
+        printExcludedCategories(result);
+        if (packOptions.dryRun) {
+            printDryRunTree(result);
+        }
+        console.log(createSuccessBox(packOptions.dryRun ? 'Dry Run Complete' : 'Project Packed', buildSummaryItems(result)));
+        showFooter();
+        await shutdownAnalytics();
+    }
+    catch (error) {
+        spinner.fail('Pack failed');
+        if (error instanceof PackValidationError) {
+            console.log(createErrorBox('Pack Failed', error.message));
+            await shutdownAnalytics();
+            process.exit(1);
+        }
+        console.log(createErrorBox('Pack Failed', error instanceof Error ? error.message : String(error)));
+        await shutdownAnalytics();
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -9,4 +9,6 @@ export { generate } from './commands/generate.js';
 export { upgradeCommand } from './commands/upgrade.js';
 export { installCommand } from './commands/install.js';
 export { cursorCommand } from './commands/cursor.js';
+export { packCommand } from './commands/pack.js';
+export { packProject } from './pack/pack-project.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,wBAAgB,aAAa,YA6E5B;AAGD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAepC,wBAAgB,aAAa,YAuF5B;AAGD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -9,6 +9,7 @@ import { generate } from './commands/generate.js';
 import { upgradeCommand } from './commands/upgrade.js';
 import { installCommand } from './commands/install.js';
 import { cursorCommand } from './commands/cursor.js';
+import { packCommand } from './commands/pack.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 export function createProgram() {
@@ -77,6 +78,15 @@ export function createProgram() {
         .option('-p, --port <port>', 'Port for default HTTP URL (for legacy-sse or streamable-http)')
         .option('--force', 'Force overwrite of existing configuration')
         .action(cursorCommand);
+    program
+        .command('pack')
+        .description('Create an optimized zip of the project (excludes build artifacts)')
+        .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(packCommand);
     return program;
 }
 // Re-export commands for programmatic use
@@ -88,6 +98,8 @@ export { generate } from './commands/generate.js';
 export { upgradeCommand } from './commands/upgrade.js';
 export { installCommand } from './commands/install.js';
 export { cursorCommand } from './commands/cursor.js';
+export { packCommand } from './commands/pack.js';
+export { packProject } from './pack/pack-project.js';
 // Run the CLI when this module is the entry point
 import { fileURLToPath } from 'url';
 import { realpathSync } from 'fs';

package/dist/pack/canonical-gitignore.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolve the bundled canonical .gitignore shipped with the CLI package.
+ */
+export declare function getCanonicalGitignorePath(): string;
+/**
+ * Load canonical .gitignore rules from the bundled starter template copy.
+ */
+export declare function loadCanonicalGitignore(): Promise<string>;
+/**
+ * Write the bundled canonical .gitignore into a project root as `.gitignore`.
+ * Used by init because npm never ships files named `.gitignore` in the package tarball.
+ */
+export declare function writeCanonicalGitignore(projectRoot: string): Promise<void>;
+//# sourceMappingURL=canonical-gitignore.d.ts.map

package/dist/pack/canonical-gitignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-gitignore.d.ts","sourceRoot":"","sources":["../../src/pack/canonical-gitignore.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED;;GAEG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,CAM9D;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhF"}

package/dist/pack/canonical-gitignore.js

@@ -0,0 +1,28 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs-extra';
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Resolve the bundled canonical .gitignore shipped with the CLI package.
+ */
+export function getCanonicalGitignorePath() {
+    return path.join(moduleDir, '../../assets/canonical.gitignore');
+}
+/**
+ * Load canonical .gitignore rules from the bundled starter template copy.
+ */
+export async function loadCanonicalGitignore() {
+    const canonicalPath = getCanonicalGitignorePath();
+    if (!(await fs.pathExists(canonicalPath))) {
+        throw new Error(`Canonical .gitignore not found at ${canonicalPath}`);
+    }
+    return fs.readFile(canonicalPath, 'utf-8');
+}
+/**
+ * Write the bundled canonical .gitignore into a project root as `.gitignore`.
+ * Used by init because npm never ships files named `.gitignore` in the package tarball.
+ */
+export async function writeCanonicalGitignore(projectRoot) {
+    const content = await loadCanonicalGitignore();
+    await fs.writeFile(path.join(projectRoot, '.gitignore'), content, 'utf-8');
+}

package/dist/pack/exclusions.d.ts

@@ -0,0 +1,8 @@
+import type { ExclusionCategory } from './types.js';
+/** Env/secret patterns excluded by default; skipped when --include-env is set. */
+export declare const ENV_EXCLUDED_PATTERNS: string[];
+/** Hard-coded exclusions always applied in addition to merged .gitignore rules. */
+export declare const HARD_EXCLUDED_PATTERNS: string[];
+export declare const EXCLUSION_CATEGORIES: ExclusionCategory[];
+export declare function getExclusionReport(includeEnv?: boolean): ExclusionCategory[];
+//# sourceMappingURL=exclusions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exclusions.d.ts","sourceRoot":"","sources":["../../src/pack/exclusions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,kFAAkF;AAClF,eAAO,MAAM,qBAAqB,EAAE,MAAM,EAIzC,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,EAAE,MAAM,EA0B1C,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,EAyCnD,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,UAAU,GAAE,OAAe,GAAG,iBAAiB,EAAE,CAOnF"}

package/dist/pack/exclusions.js

@@ -0,0 +1,84 @@
+/** Env/secret patterns excluded by default; skipped when --include-env is set. */
+export const ENV_EXCLUDED_PATTERNS = [
+    '.env',
+    '.env.local',
+    '.env.*.local',
+];
+/** Hard-coded exclusions always applied in addition to merged .gitignore rules. */
+export const HARD_EXCLUDED_PATTERNS = [
+    '.git/',
+    '**/node_modules/',
+    '**/dist/',
+    '**/build/',
+    '**/out/',
+    '**/.next/',
+    '*.tsbuildinfo',
+    '.npm/',
+    '.eslintcache',
+    'coverage/',
+    '.nyc_output/',
+    'tmp/',
+    'temp/',
+    'pids/',
+    'uploads/',
+    ...ENV_EXCLUDED_PATTERNS,
+    '.idea/',
+    '.vscode/',
+    '.DS_Store',
+    'Thumbs.db',
+    '*.log',
+    'npm-debug.log*',
+    'yarn-debug.log*',
+    'yarn-error.log*',
+    '*.zip',
+];
+export const EXCLUSION_CATEGORIES = [
+    {
+        category: 'VCS',
+        paths: ['.git/'],
+    },
+    {
+        category: 'Dependencies',
+        paths: ['**/node_modules/'],
+    },
+    {
+        category: 'Build outputs',
+        paths: ['**/dist/', '**/build/', '**/out/', '**/.next/'],
+    },
+    {
+        category: 'Caches',
+        paths: ['*.tsbuildinfo', '.npm/', '.eslintcache'],
+    },
+    {
+        category: 'Test',
+        paths: ['coverage/', '.nyc_output/'],
+    },
+    {
+        category: 'Temp/runtime',
+        paths: ['tmp/', 'temp/', 'pids/', 'uploads/'],
+    },
+    {
+        category: 'Secrets',
+        paths: [...ENV_EXCLUDED_PATTERNS],
+    },
+    {
+        category: 'IDE/OS',
+        paths: ['.idea/', '.vscode/', '.DS_Store', 'Thumbs.db'],
+    },
+    {
+        category: 'Logs',
+        paths: ['*.log', 'npm-debug.log*', 'yarn-debug.log*', 'yarn-error.log*'],
+    },
+    {
+        category: 'Archives',
+        paths: ['*.zip'],
+    },
+];
+export function getExclusionReport(includeEnv = false) {
+    return EXCLUSION_CATEGORIES
+        .filter((entry) => !(includeEnv && entry.category === 'Secrets'))
+        .map((entry) => ({
+        category: entry.category,
+        paths: [...entry.paths],
+    }));
+}

package/dist/pack/gitignore.d.ts

@@ -0,0 +1,21 @@
+import { type IgnoreMatcher } from './ignore-matcher.js';
+import type { GitignoreMergeResult } from './types.js';
+export interface BuildIgnoreMatcherOptions {
+    includeEnv?: boolean;
+}
+export type { IgnoreMatcher };
+/**
+ * Non-destructively merge canonical rules into a local .gitignore.
+ * Existing local rules are preserved; only missing canonical rules are appended.
+ */
+export declare function mergeGitignoreRules(localContent: string, canonicalContent: string): GitignoreMergeResult;
+/**
+ * Sync local .gitignore with canonical rules when enabled.
+ */
+export declare function syncProjectGitignore(projectRoot: string, syncGitignore: boolean): Promise<GitignoreMergeResult>;
+/**
+ * Build a gitignore matcher from merged project rules and hard-coded exclusions.
+ */
+export declare function buildIgnoreMatcher(mergedGitignoreContent: string, options?: BuildIgnoreMatcherOptions): IgnoreMatcher;
+export declare function isPathIgnored(matcher: IgnoreMatcher, projectRoot: string, absolutePath: string, isDirectory?: boolean): boolean;
+//# sourceMappingURL=gitignore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gitignore.d.ts","sourceRoot":"","sources":["../../src/pack/gitignore.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAIvD,MAAM,WAAW,yBAAyB;IACxC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,YAAY,EAAE,aAAa,EAAE,CAAC;AA2B9B;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,GACvB,oBAAoB,CAuCtB;AAQD;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,OAAO,GACrB,OAAO,CAAC,oBAAoB,CAAC,CAoB/B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,sBAAsB,EAAE,MAAM,EAC9B,OAAO,GAAE,yBAA8B,GACtC,aAAa,CAyBf;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,WAAW,GAAE,OAAe,GAC3B,OAAO,CAMT"}

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"}