@edcalderon/versioning 1.1.2 → 1.3.0

package/dist/extensions/reentry-status/config-manager.js

@@ -84,7 +84,9 @@ function defaultFilesConfigForProject(project) {
 class ConfigManager {
     static loadConfig(rootConfig, project) {
         const canonicalProject = canonicalProjectKey(project);
-        const raw = (rootConfig && typeof rootConfig === 'object' ? rootConfig.reentryStatus : undefined);
+        // Try new extensionConfig location first, then fallback to root-level property
+        const extensionConfig = rootConfig?.extensionConfig?.['reentry-status'];
+        const raw = (extensionConfig ?? (rootConfig && typeof rootConfig === 'object' ? rootConfig.reentryStatus : undefined));
         const basePartial = { ...(raw ?? {}) };
         delete basePartial.projects;
         const projectPartial = canonicalProject && raw && typeof raw === 'object' && raw.projects && typeof raw.projects === 'object'

package/dist/extensions/reentry-status/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const REENTRY_EXTENSION_NAME = "reentry-status-extension";
+export declare const REENTRY_EXTENSION_NAME = "reentry-status";
 export declare const REENTRY_STATUS_DIRNAME = ".versioning";
 export declare const REENTRY_STATUS_JSON_FILENAME = "reentry.status.json";
 export declare const REENTRY_STATUS_MD_FILENAME = "REENTRY.md";

package/dist/extensions/reentry-status/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ROADMAP_MD_FILENAME = exports.REENTRY_STATUS_MD_FILENAME = exports.REENTRY_STATUS_JSON_FILENAME = exports.REENTRY_STATUS_DIRNAME = exports.REENTRY_EXTENSION_NAME = void 0;
-exports.REENTRY_EXTENSION_NAME = 'reentry-status-extension';
+exports.REENTRY_EXTENSION_NAME = 'reentry-status';
 exports.REENTRY_STATUS_DIRNAME = '.versioning';
 exports.REENTRY_STATUS_JSON_FILENAME = 'reentry.status.json';
 exports.REENTRY_STATUS_MD_FILENAME = 'REENTRY.md';

package/dist/extensions/reentry-status/extension.d.ts

@@ -0,0 +1,4 @@
+import { VersioningExtension } from '../../extensions';
+declare const extension: VersioningExtension;
+export default extension;
+//# sourceMappingURL=extension.d.ts.map

package/dist/extensions/{reentry-status-extension.js → reentry-status/extension.js}

@@ -36,26 +36,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
-const config_manager_1 = require("./reentry-status/config-manager");
-const constants_1 = require("./reentry-status/constants");
-const file_manager_1 = require("./reentry-status/file-manager");
-const dirty_detection_1 = require("./reentry-status/dirty-detection");
-const github_rest_client_1 = require("./reentry-status/github-rest-client");
-const github_sync_adapter_1 = require("./reentry-status/github-sync-adapter");
-const obsidian_cli_client_1 = require("./reentry-status/obsidian-cli-client");
-const obsidian_sync_adapter_1 = require("./reentry-status/obsidian-sync-adapter");
-const roadmap_parser_1 = require("./reentry-status/roadmap-parser");
-const roadmap_renderer_1 = require("./reentry-status/roadmap-renderer");
-const status_renderer_1 = require("./reentry-status/status-renderer");
-const reentry_status_manager_1 = require("./reentry-status/reentry-status-manager");
+const config_manager_1 = require("./config-manager");
+const constants_1 = require("./constants");
+const file_manager_1 = require("./file-manager");
+const dirty_detection_1 = require("./dirty-detection");
+const github_rest_client_1 = require("./github-rest-client");
+const github_sync_adapter_1 = require("./github-sync-adapter");
+const obsidian_cli_client_1 = require("./obsidian-cli-client");
+const obsidian_sync_adapter_1 = require("./obsidian-sync-adapter");
+const roadmap_parser_1 = require("./roadmap-parser");
+const roadmap_renderer_1 = require("./roadmap-renderer");
+const status_renderer_1 = require("./status-renderer");
+const reentry_status_manager_1 = require("./reentry-status-manager");
+const git_context_1 = require("./git-context");
 const extension = {
     name: constants_1.REENTRY_EXTENSION_NAME,
     description: 'Maintains canonical re-entry status and synchronizes to files, GitHub Issues, and Obsidian notes',
-    version: '1.1.2',
+    version: '1.2.0',
     hooks: {
         postVersion: async (type, version, options) => {
             try {
-                // Extensions are loaded before the CLI reads config per-command; use global config snapshot.
                 const configPath = options?.config ?? 'versioning.config.json';
                 if (!(await fs.pathExists(configPath)))
                     return;
@@ -65,15 +65,42 @@ const extension = {
                     return;
                 if (reentryCfg.hooks?.postVersion === false)
                     return;
+                // Auto-collect real git context
+                const gitCtx = await (0, git_context_1.collectGitContext)();
                 const manager = new reentry_status_manager_1.ReentryStatusManager({ fileManager: new file_manager_1.FileManager() });
                 await manager.applyContext(cfg, {
                     trigger: 'postVersion',
                     command: 'versioning bump',
                     options,
-                    gitInfo: { branch: '', commit: '', author: '', timestamp: new Date().toISOString() },
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
                     versioningInfo: { versionType: type, oldVersion: undefined, newVersion: version }
                 });
+                // Auto-update phase and suggest next step
+                const current = await manager.loadOrInit(cfg);
+                const phase = (0, git_context_1.inferPhase)(gitCtx, version);
+                const nextStep = (0, git_context_1.suggestNextStep)(gitCtx);
+                const updated = {
+                    ...current,
+                    schemaVersion: '1.1',
+                    currentPhase: phase,
+                    nextSteps: [{ id: 'next', description: nextStep, priority: 1 }],
+                    version: version,
+                    versioning: {
+                        ...current.versioning,
+                        currentVersion: version,
+                        previousVersion: current.versioning.currentVersion,
+                        versionType: type,
+                    },
+                    lastUpdated: new Date().toISOString(),
+                };
+                await manager.updateStatus(cfg, () => updated);
                 await manager.syncAll(cfg);
+                console.log(`📋 Re-entry auto-updated: phase=${phase}, next="${nextStep}"`);
             }
             catch (error) {
                 console.warn('⚠️  reentry-status postVersion hook failed:', error instanceof Error ? error.message : String(error));
@@ -90,12 +117,19 @@ const extension = {
                     return;
                 if (reentryCfg.hooks?.postRelease !== true)
                     return;
+                // Auto-collect real git context
+                const gitCtx = await (0, git_context_1.collectGitContext)();
                 const manager = new reentry_status_manager_1.ReentryStatusManager({ fileManager: new file_manager_1.FileManager() });
                 await manager.applyContext(cfg, {
                     trigger: 'postRelease',
                     command: 'versioning release',
                     options,
-                    gitInfo: { branch: '', commit: '', author: '', timestamp: new Date().toISOString() },
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
                     versioningInfo: { newVersion: version }
                 });
                 await manager.syncAll(cfg);
@@ -209,7 +243,6 @@ const extension = {
             if (existingJson) {
                 const parsed = status_renderer_1.StatusRenderer.parseJson(existingJson);
                 if (migrate && parsed.schemaVersion === '1.0') {
-                    // Explicit migration: rewrite as 1.1 without changing semantics.
                     const migrated = {
                         ...parsed,
                         schemaVersion: '1.1',
@@ -257,6 +290,9 @@ const extension = {
             await fileManager.writeStatusFiles(cfg, initial);
             return { cfg, status: initial };
         };
+        // ─────────────────────────────────────────────
+        //  REENTRY COMMANDS
+        // ─────────────────────────────────────────────
         program
             .command('reentry')
             .description('Manage re-entry status (fast layer)')
@@ -291,6 +327,114 @@ const extension = {
             };
             await manager.updateStatus(cfg, () => updated);
             console.log('✅ Re-entry status updated');
+        }))
+            .addCommand(new commander_1.Command('update')
+            .description('Auto-fill re-entry status from last commit and current version (smart reentry)')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope')
+            .option('--phase <phase>', 'Override inferred phase')
+            .option('--next <text>', 'Override suggested next step')
+            .option('--dry-run', 'Show what would be updated without writing', false)
+            .action(async (options) => {
+            const { cfg, status } = await ensureReentryInitialized(options.config, false, options.project);
+            // Auto-collect git context
+            const gitCtx = await (0, git_context_1.collectGitContext)();
+            // Read current version from package.json
+            let currentVersion = status.versioning.currentVersion;
+            try {
+                const rootPkg = await fs.readJson('package.json');
+                currentVersion = rootPkg.version || currentVersion;
+            }
+            catch { /* keep existing */ }
+            // Infer phase or use override
+            const phase = options.phase || (0, git_context_1.inferPhase)(gitCtx, currentVersion);
+            // Suggest next step or use override
+            const nextStep = options.next || (0, git_context_1.suggestNextStep)(gitCtx);
+            const updated = {
+                ...status,
+                schemaVersion: '1.1',
+                version: currentVersion,
+                currentPhase: phase,
+                nextSteps: [{ id: 'next', description: nextStep, priority: 1 }],
+                context: {
+                    trigger: 'auto',
+                    command: 'versioning reentry update',
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
+                    versioningInfo: {
+                        newVersion: currentVersion,
+                    },
+                },
+                versioning: {
+                    ...status.versioning,
+                    currentVersion: currentVersion,
+                    previousVersion: status.versioning.currentVersion !== currentVersion
+                        ? status.versioning.currentVersion
+                        : status.versioning.previousVersion,
+                },
+                lastUpdated: new Date().toISOString(),
+                updatedBy: gitCtx.author || 'auto',
+            };
+            if (options.dryRun) {
+                console.log('\n📋 Re-entry Update Preview (dry-run)\n');
+                console.log(`  Branch:       ${gitCtx.branch}`);
+                console.log(`  Commit:       ${gitCtx.commit}`);
+                console.log(`  Message:      ${gitCtx.commitMessage}`);
+                console.log(`  Author:       ${gitCtx.author}`);
+                console.log(`  Version:      ${currentVersion}`);
+                console.log(`  Phase:        ${phase}`);
+                console.log(`  Next step:    ${nextStep}`);
+                console.log(`  Files changed: ${gitCtx.diffSummary.filesChanged} (+${gitCtx.diffSummary.insertions}/-${gitCtx.diffSummary.deletions})`);
+                console.log('\n  Use without --dry-run to apply.\n');
+                return;
+            }
+            await manager.updateStatus(cfg, () => updated);
+            console.log('\n📋 Re-entry Status Auto-Updated\n');
+            console.log(`  ├─ Branch:       ${gitCtx.branch}`);
+            console.log(`  ├─ Commit:       ${gitCtx.commit} — ${gitCtx.commitMessage}`);
+            console.log(`  ├─ Version:      ${currentVersion}`);
+            console.log(`  ├─ Phase:        ${phase}`);
+            console.log(`  ├─ Next step:    ${nextStep}`);
+            console.log(`  └─ Updated by:   ${gitCtx.author || 'auto'}\n`);
+            console.log('  🔜 Suggested workflow:');
+            console.log('     1. Review next step above');
+            console.log('     2. Work on the task');
+            console.log('     3. Commit & push');
+            console.log('     4. Run `versioning reentry update` again\n');
+        }))
+            .addCommand(new commander_1.Command('show')
+            .description('Show current re-entry status summary')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope')
+            .option('--json', 'Output as JSON', false)
+            .action(async (options) => {
+            const { status } = await ensureReentryInitialized(options.config, false, options.project);
+            if (options.json) {
+                console.log(JSON.stringify(status, null, 2));
+                return;
+            }
+            const milestoneText = status.milestone
+                ? `${status.milestone.title} (${status.milestone.id})`
+                : '—';
+            const nextStep = status.nextSteps?.[0]?.description ?? '—';
+            const gitCommit = status.context?.gitInfo?.commit || '—';
+            const gitBranch = status.context?.gitInfo?.branch || '—';
+            console.log('\n┌───────────────────────────────────────────┐');
+            console.log('│         📋 Re-entry Status Summary         │');
+            console.log('├───────────────────────────────────────────┤');
+            console.log(`│  Version:     ${status.version.padEnd(28)}│`);
+            console.log(`│  Phase:       ${status.currentPhase.padEnd(28)}│`);
+            console.log(`│  Branch:      ${gitBranch.padEnd(28)}│`);
+            console.log(`│  Commit:      ${gitCommit.padEnd(28)}│`);
+            console.log(`│  Milestone:   ${milestoneText.padEnd(28).substring(0, 28)}│`);
+            console.log(`│  Next step:   ${nextStep.padEnd(28).substring(0, 28)}│`);
+            console.log(`│  Updated:     ${status.lastUpdated.substring(0, 19).padEnd(28)}│`);
+            console.log(`│  Roadmap:     ${status.roadmapFile.padEnd(28).substring(0, 28)}│`);
+            console.log('└───────────────────────────────────────────┘\n');
         }))
             .addCommand(new commander_1.Command('sync')
             .description('Ensure generated status files exist and are up to date (idempotent)')
@@ -384,6 +528,9 @@ const extension = {
             }
             console.log('✅ Re-entry sync complete');
         }));
+        // ─────────────────────────────────────────────
+        //  ROADMAP COMMANDS (expanded with project identification)
+        // ─────────────────────────────────────────────
         program
             .command('roadmap')
             .description('Manage roadmap/backlog (slow layer)')
@@ -525,4 +672,4 @@ const extension = {
     }
 };
 exports.default = extension;
-//# sourceMappingURL=reentry-status-extension.js.map
+//# sourceMappingURL=extension.js.map

package/dist/extensions/reentry-status/git-context.d.ts

@@ -0,0 +1,27 @@
+export interface GitContextInfo {
+    branch: string;
+    commit: string;
+    commitMessage: string;
+    author: string;
+    timestamp: string;
+    changedFiles: string[];
+    diffSummary: {
+        insertions: number;
+        deletions: number;
+        filesChanged: number;
+    };
+}
+/**
+ * Collects the current git context automatically from the working directory.
+ * This is used to auto-fill the reentry status with real git data.
+ */
+export declare function collectGitContext(): Promise<GitContextInfo>;
+/**
+ * Infer the current project phase based on git data and recent changes.
+ */
+export declare function inferPhase(context: GitContextInfo, currentVersion: string): string;
+/**
+ * Generate a suggested next step based on the last commit context.
+ */
+export declare function suggestNextStep(context: GitContextInfo): string;
+//# sourceMappingURL=git-context.d.ts.map

package/dist/extensions/reentry-status/git-context.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectGitContext = collectGitContext;
+exports.inferPhase = inferPhase;
+exports.suggestNextStep = suggestNextStep;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * Collects the current git context automatically from the working directory.
+ * This is used to auto-fill the reentry status with real git data.
+ */
+async function collectGitContext() {
+    const git = (0, simple_git_1.default)();
+    try {
+        const [log, branch, diff] = await Promise.all([
+            git.log({ maxCount: 1 }),
+            git.branch(),
+            git.diffSummary(['HEAD~1', 'HEAD']).catch(() => null),
+        ]);
+        const latest = log.latest;
+        const statusResult = await git.status();
+        return {
+            branch: branch.current || '',
+            commit: latest?.hash?.substring(0, 7) || '',
+            commitMessage: latest?.message || '',
+            author: latest?.author_name || '',
+            timestamp: latest?.date || new Date().toISOString(),
+            changedFiles: statusResult.files.map(f => f.path),
+            diffSummary: {
+                insertions: diff?.insertions ?? 0,
+                deletions: diff?.deletions ?? 0,
+                filesChanged: diff?.changed ?? 0,
+            },
+        };
+    }
+    catch {
+        return {
+            branch: '',
+            commit: '',
+            commitMessage: '',
+            author: '',
+            timestamp: new Date().toISOString(),
+            changedFiles: [],
+            diffSummary: { insertions: 0, deletions: 0, filesChanged: 0 },
+        };
+    }
+}
+/**
+ * Infer the current project phase based on git data and recent changes.
+ */
+function inferPhase(context, currentVersion) {
+    const msg = context.commitMessage.toLowerCase();
+    if (msg.startsWith('fix:') || msg.startsWith('hotfix:') || msg.includes('bugfix')) {
+        return 'maintenance';
+    }
+    if (msg.startsWith('test:') || msg.includes('test')) {
+        return 'testing';
+    }
+    if (msg.startsWith('feat:') || msg.startsWith('feature:')) {
+        return 'development';
+    }
+    if (msg.startsWith('chore: release') || msg.includes('deploy') || msg.includes('staging')) {
+        return 'staging';
+    }
+    if (msg.startsWith('docs:') || msg.startsWith('chore:')) {
+        return 'maintenance';
+    }
+    return 'development';
+}
+/**
+ * Generate a suggested next step based on the last commit context.
+ */
+function suggestNextStep(context) {
+    const msg = context.commitMessage.toLowerCase();
+    if (msg.startsWith('feat:')) {
+        return `Write tests for: ${context.commitMessage.replace(/^feat:\s*/i, '').substring(0, 60)}`;
+    }
+    if (msg.startsWith('fix:')) {
+        return `Verify fix and add regression test for: ${context.commitMessage.replace(/^fix:\s*/i, '').substring(0, 50)}`;
+    }
+    if (msg.startsWith('test:')) {
+        return 'Review test coverage and consider edge cases';
+    }
+    if (msg.startsWith('chore: release')) {
+        return 'Verify deployment and update documentation';
+    }
+    if (msg.startsWith('docs:')) {
+        return 'Continue with next feature or bugfix';
+    }
+    return `Review changes from: ${context.commitMessage.substring(0, 60)}`;
+}
+//# sourceMappingURL=git-context.js.map

package/dist/extensions/reentry-status/index.d.ts

@@ -9,6 +9,9 @@ export * from './obsidian-sync-adapter';
 export * from './obsidian-cli-client';
 export * from './roadmap-parser';
 export * from './roadmap-renderer';
+export * from './git-context';
 export * from './reentry-status-manager';
 export * from './status-renderer';
+import extension from './extension';
+export default extension;
 //# sourceMappingURL=index.d.ts.map

package/dist/extensions/reentry-status/index.js

@@ -13,6 +13,9 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./constants"), exports);
 __exportStar(require("./config-manager"), exports);
@@ -25,6 +28,9 @@ __exportStar(require("./obsidian-sync-adapter"), exports);
 __exportStar(require("./obsidian-cli-client"), exports);
 __exportStar(require("./roadmap-parser"), exports);
 __exportStar(require("./roadmap-renderer"), exports);
+__exportStar(require("./git-context"), exports);
 __exportStar(require("./reentry-status-manager"), exports);
 __exportStar(require("./status-renderer"), exports);
+const extension_1 = __importDefault(require("./extension"));
+exports.default = extension_1.default;
 //# sourceMappingURL=index.js.map

package/dist/extensions/reentry-status/roadmap-renderer.d.ts

@@ -3,9 +3,16 @@ export declare const ROADMAP_MANAGED_START = "<!-- roadmap:managed:start -->";
 export declare const ROADMAP_MANAGED_END = "<!-- roadmap:managed:end -->";
 export interface RoadmapRenderOptions {
     projectTitle?: string;
+    projectSlug?: string;
+    monorepoName?: string;
 }
 export declare class RoadmapRenderer {
     static defaultRoadmapPath(baseDir?: string): string;
+    /**
+     * Extract the project name from the roadmap file path for auto-identification.
+     * e.g. ".versioning/projects/trader/ROADMAP.md" → "trader"
+     */
+    static extractProjectFromPath(roadmapFile: string): string | null;
     static renderManagedBlock(status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): string;
     static renderTemplate(options?: RoadmapRenderOptions, status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): string;
     /**

package/dist/extensions/reentry-status/roadmap-renderer.js

@@ -8,28 +8,45 @@ class RoadmapRenderer {
     static defaultRoadmapPath(baseDir = constants_1.REENTRY_STATUS_DIRNAME) {
         return `${baseDir}/${constants_1.ROADMAP_MD_FILENAME}`;
     }
+    /**
+     * Extract the project name from the roadmap file path for auto-identification.
+     * e.g. ".versioning/projects/trader/ROADMAP.md" → "trader"
+     */
+    static extractProjectFromPath(roadmapFile) {
+        const normalized = roadmapFile.replace(/\\/g, '/');
+        const match = /\.versioning\/projects\/([^/]+)\/ROADMAP\.md$/.exec(normalized);
+        return match ? match[1] : null;
+    }
     static renderManagedBlock(status) {
         const milestoneText = status?.milestone
             ? `${status.milestone.title} (id: ${status.milestone.id})`
             : '—';
         const roadmapFile = status?.roadmapFile ?? RoadmapRenderer.defaultRoadmapPath();
-        // Keep this block stable: no timestamps.
-        return [
+        const projectSlug = RoadmapRenderer.extractProjectFromPath(roadmapFile);
+        // Build the managed block with project identification
+        const lines = [
             exports.ROADMAP_MANAGED_START,
             '> Managed by `@edcalderon/versioning` reentry-status-extension.',
             `> Canonical roadmap file: ${roadmapFile}`,
-            `> Active milestone: ${milestoneText}`,
-            '> ',
-            '> Everything outside this block is user-editable.',
-            exports.ROADMAP_MANAGED_END,
-            ''
-        ].join('\n');
+        ];
+        if (projectSlug) {
+            lines.push(`> Project: **${projectSlug}**`);
+        }
+        lines.push(`> Active milestone: ${milestoneText}`, '> ', '> Everything outside this block is user-editable.', exports.ROADMAP_MANAGED_END, '');
+        return lines.join('\n');
     }
     static renderTemplate(options = {}, status) {
         const title = options.projectTitle?.trim() ? options.projectTitle.trim() : 'Untitled';
+        const roadmapFile = status?.roadmapFile ?? RoadmapRenderer.defaultRoadmapPath();
+        const projectSlug = options.projectSlug || RoadmapRenderer.extractProjectFromPath(roadmapFile);
+        const monorepo = options.monorepoName || '@ed/monorepo';
+        const headerLines = [`# Project Roadmap – ${title}`, ''];
+        // Add project metadata section
+        if (projectSlug) {
+            headerLines.push(`> 📦 **Project:** \`${projectSlug}\` | **Monorepo:** \`${monorepo}\``, '');
+        }
         return [
-            `# Project Roadmap – ${title}`,
-            '',
+            ...headerLines,
             RoadmapRenderer.renderManagedBlock(status),
             '## North Star',
             '',

package/dist/extensions/sample-extension/index.d.ts

@@ -0,0 +1,4 @@
+import { VersioningExtension } from '../../extensions';
+declare const extension: VersioningExtension;
+export default extension;
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/{sample-extension.js → sample-extension/index.js}

@@ -51,4 +51,4 @@ const extension = {
     }
 };
 exports.default = extension;
-//# sourceMappingURL=sample-extension.js.map
+//# sourceMappingURL=index.js.map

package/dist/extensions/secrets-check/index.d.ts

@@ -0,0 +1,16 @@
+import { VersioningExtension } from '../../extensions';
+export interface SecretCheckResult {
+    file: string;
+    line: number;
+    content: string;
+    pattern: string;
+}
+export interface SecretsConfig {
+    enabled?: boolean;
+    patterns?: string[];
+    allowlist?: string[];
+}
+export declare function checkContentForSecrets(content: string, patterns: RegExp[], allowlist: string[], filename: string): SecretCheckResult[];
+declare const extension: VersioningExtension;
+export default extension;
+//# sourceMappingURL=index.d.ts.map