@webpresso/agent-kit 0.21.0

package/dist/esm/blueprint/service/blueprint-records.d.ts

@@ -0,0 +1,8 @@
+import type { BlueprintQueryFilters, BlueprintQueryResult, BlueprintRecord, BlueprintSortOptions } from '#query/types';
+export declare function toBlueprintRecord(filePath: string, slug: string, group: string | null): Promise<BlueprintRecord | null>;
+export declare function extractTitle(raw: string): string | null;
+export declare function extractFilesTouched(raw: string): string[];
+export declare function matchesBlueprintFilters(plan: BlueprintRecord, filters: BlueprintQueryFilters, matchesFilter: (value: string, filter: string | string[]) => boolean): boolean;
+export declare function sortBlueprintRecords(plans: BlueprintRecord[], sort: BlueprintSortOptions): BlueprintRecord[];
+export declare function computeBlueprintQuerySummary(allPlans: BlueprintRecord[], totalFiltered: number, countByField: (records: BlueprintRecord[], selector: (record: BlueprintRecord) => string) => Record<string, number>, isStale: (plan: BlueprintRecord) => boolean): BlueprintQueryResult['summary'];
+//# sourceMappingURL=blueprint-records.d.ts.map

package/dist/esm/blueprint/service/blueprint-records.js

@@ -0,0 +1,124 @@
+import * as fs from 'node:fs/promises';
+import { parseBlueprint } from '#core/parser';
+import { isBlueprintStatus, isComplexity } from '#query/types';
+import { calculateFreshness } from '#utils/freshness';
+export async function toBlueprintRecord(filePath, slug, group) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const plan = parseBlueprint(content, slug);
+        const planStatus = isBlueprintStatus(plan.status) ? plan.status : 'draft';
+        const lastUpdated = plan.lastUpdated ? new Date(plan.lastUpdated) : new Date();
+        const freshness = calculateFreshness(lastUpdated, planStatus);
+        const tasksCompleted = plan.tasks.filter((task) => task.status === 'done').length;
+        return {
+            name: slug,
+            title: extractTitle(plan.raw) ?? slug,
+            status: planStatus,
+            complexity: isComplexity(plan.complexity) ? plan.complexity : undefined,
+            taskCount: plan.tasks.length,
+            tasksCompleted,
+            group,
+            path: filePath,
+            lastUpdated,
+            freshness,
+            filesTouched: extractFilesTouched(plan.raw),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function extractTitle(raw) {
+    const match = raw.match(/^#\s+(.+)$/m);
+    return match?.[1]?.trim() ?? null;
+}
+export function extractFilesTouched(raw) {
+    const filesSection = raw.match(/\*\*Files:\*\*\s*([\s\S]*?)(?=\n\*\*|\n###|\n####|$)/gi);
+    if (!filesSection)
+        return [];
+    const allPaths = filesSection.flatMap((section) => extractPathsFromSection(section));
+    return [...new Set(allPaths)];
+}
+function extractPathsFromSection(section) {
+    const pathMatches = section.match(/[`-]\s*`?([^`\n]+\.[a-z]+)`?/gi);
+    if (!pathMatches)
+        return [];
+    return pathMatches
+        .map((match) => match
+        .replace(/^[`-]\s*`?/, '')
+        .replace(/`$/, '')
+        .trim())
+        .filter((path) => path.length > 0);
+}
+export function matchesBlueprintFilters(plan, filters, matchesFilter) {
+    return (matchesStatusFilter(plan, filters, matchesFilter) &&
+        matchesGroupFilter(plan, filters, matchesFilter) &&
+        matchesComplexityFilter(plan, filters, matchesFilter) &&
+        matchesStaleFilter(plan, filters) &&
+        matchesFilesTouchedFilter(plan, filters));
+}
+function matchesStatusFilter(plan, filters, matchesFilter) {
+    if (!filters.status)
+        return true;
+    return matchesFilter(plan.status, filters.status);
+}
+function matchesGroupFilter(plan, filters, matchesFilter) {
+    if (!filters.group)
+        return true;
+    return plan.group !== null && matchesFilter(plan.group, filters.group);
+}
+function matchesComplexityFilter(plan, filters, matchesFilter) {
+    if (!filters.complexity)
+        return true;
+    return plan.complexity !== undefined && matchesFilter(plan.complexity, filters.complexity);
+}
+function matchesStaleFilter(plan, filters) {
+    if (!filters.stale)
+        return true;
+    return plan.freshness.status === 'stale' || plan.freshness.status === 'critical';
+}
+function matchesFilesTouchedFilter(plan, filters) {
+    if (!filters.filesTouched || !filters.filesTouched.length)
+        return true;
+    return filters.filesTouched.some((file) => plan.filesTouched.includes(file));
+}
+export function sortBlueprintRecords(plans, sort) {
+    const sorted = [...plans];
+    const direction = sort.direction === 'asc' ? 1 : -1;
+    sorted.sort((a, b) => {
+        let comparison = 0;
+        switch (sort.field) {
+            case 'freshness':
+                comparison = a.freshness.score - b.freshness.score;
+                break;
+            case 'lastUpdated':
+                comparison = a.lastUpdated.getTime() - b.lastUpdated.getTime();
+                break;
+            case 'taskCount':
+                comparison = a.taskCount - b.taskCount;
+                break;
+            case 'name':
+                comparison = a.name.localeCompare(b.name);
+                break;
+            case 'status':
+                comparison = a.status.localeCompare(b.status);
+                break;
+        }
+        return comparison * direction;
+    });
+    return sorted;
+}
+export function computeBlueprintQuerySummary(allPlans, totalFiltered, countByField, isStale) {
+    const byStatus = countByField(allPlans, (plan) => plan.status);
+    const byGroup = countByField(allPlans.filter((plan) => plan.group !== null), (plan) => plan.group);
+    const staleCount = allPlans.filter((plan) => isStale(plan)).length;
+    const totalFreshness = allPlans.reduce((sum, plan) => sum + plan.freshness.score, 0);
+    return {
+        total: totalFiltered,
+        byStatus,
+        byGroup,
+        staleCount,
+        avgFreshness: allPlans.length > 0 ? totalFreshness / allPlans.length : 1.0,
+    };
+}
+//# sourceMappingURL=blueprint-records.js.map

package/dist/esm/blueprint/service/blueprint-tech-debt-links.d.ts

@@ -0,0 +1,3 @@
+export declare function linkBlueprintToTechDebt(baseDir: string, projectPath: string | undefined, bpSlug: string, tdSlug: string): Promise<void>;
+export declare function unlinkBlueprintFromTechDebt(baseDir: string, projectPath: string | undefined, bpSlug: string, tdSlug: string): Promise<void>;
+//# sourceMappingURL=blueprint-tech-debt-links.d.ts.map

package/dist/esm/blueprint/service/blueprint-tech-debt-links.js

@@ -0,0 +1,35 @@
+import matter from 'gray-matter';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { resolveTechDebtRoot } from '#utils/tech-debt-root';
+export async function linkBlueprintToTechDebt(baseDir, projectPath, bpSlug, tdSlug) {
+    const blueprintPath = path.join(baseDir, bpSlug, '_overview.md');
+    await updateLinkedSlugs(blueprintPath, 'linked_tech_debt_slugs', (linked) => [...linked, tdSlug]);
+    const tdPath = path.join(resolveTechDebtRoot(projectPath), tdSlug, 'README.md');
+    await updateLinkedSlugs(tdPath, 'linked_blueprints', (linked) => [...linked, bpSlug]);
+}
+export async function unlinkBlueprintFromTechDebt(baseDir, projectPath, bpSlug, tdSlug) {
+    const blueprintPath = path.join(baseDir, bpSlug, '_overview.md');
+    await updateLinkedSlugs(blueprintPath, 'linked_tech_debt_slugs', (linked) => linked.filter((slug) => slug !== tdSlug));
+    const tdPath = path.join(resolveTechDebtRoot(projectPath), tdSlug, 'README.md');
+    try {
+        await updateLinkedSlugs(tdPath, 'linked_blueprints', (linked) => linked.filter((slug) => slug !== bpSlug));
+    }
+    catch {
+        // Tech debt file may not exist during unlink.
+    }
+}
+async function updateLinkedSlugs(filePath, field, transform) {
+    const rawContent = await fs.readFile(filePath, 'utf-8');
+    const parsed = matter(rawContent);
+    const data = JSON.parse(JSON.stringify(parsed.data));
+    const linked = data[field] ?? [];
+    const nextLinked = [...new Set(transform(linked))];
+    if (linked.length === nextLinked.length &&
+        linked.every((value, index) => value === nextLinked[index])) {
+        return;
+    }
+    data[field] = nextLinked;
+    await fs.writeFile(filePath, matter.stringify(parsed.content, data), 'utf-8');
+}
+//# sourceMappingURL=blueprint-tech-debt-links.js.map

package/dist/esm/blueprint/service/priority-scoring.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Priority Scoring Algorithm for Technical Debt
+ *
+ * Calculates a 0-100 priority score based on multiple factors:
+ * - Severity (10-40 points)
+ * - Staleness (0-30 points)
+ * - Overdue review (0-20 points)
+ * - Active blueprint link (0-10 points)
+ * - Category urgency (0-5 points)
+ */
+import type { BlueprintRecord } from '#query/types';
+import type { TechDebtRecord } from '#tech-debt/index';
+/**
+ * Compute priority score for a tech debt item
+ *
+ * @param item - The tech debt record to score
+ * @param linkedBlueprints - Blueprints that reference this tech debt item
+ * @returns Priority score from 0-100 (higher = more urgent)
+ */
+export declare function computePriorityScore(item: TechDebtRecord, linkedBlueprints: BlueprintRecord[]): number;
+//# sourceMappingURL=priority-scoring.d.ts.map

package/dist/esm/blueprint/service/priority-scoring.js

@@ -0,0 +1,85 @@
+/**
+ * Priority Scoring Algorithm for Technical Debt
+ *
+ * Calculates a 0-100 priority score based on multiple factors:
+ * - Severity (10-40 points)
+ * - Staleness (0-30 points)
+ * - Overdue review (0-20 points)
+ * - Active blueprint link (0-10 points)
+ * - Category urgency (0-5 points)
+ */
+/**
+ * Compute priority score for a tech debt item
+ *
+ * @param item - The tech debt record to score
+ * @param linkedBlueprints - Blueprints that reference this tech debt item
+ * @returns Priority score from 0-100 (higher = more urgent)
+ */
+export function computePriorityScore(item, linkedBlueprints) {
+    let score = 0;
+    // Severity (10-40 points)
+    score += computeSeverityPoints(item.severity);
+    // Staleness (0-30 points) - how long since last review
+    if (item.lastReviewed) {
+        score += computeStalenessPoints(item.lastReviewed);
+    }
+    // Overdue review (0-20 points)
+    if (item.nextReview && isOverdue(item.nextReview)) {
+        score += 20;
+    }
+    // Active blueprints (0-10 points)
+    if (hasActiveBlueprintLink(linkedBlueprints)) {
+        score += 10;
+    }
+    // Category urgency (0-5 points)
+    if (item.category) {
+        score += computeCategoryPoints(item.category);
+    }
+    // Cap at 100
+    return Math.min(score, 100);
+}
+/**
+ * Compute points based on severity level
+ * Critical=40, High=30, Medium=20, Low=10
+ */
+function computeSeverityPoints(severity) {
+    const severityPoints = {
+        critical: 40,
+        high: 30,
+        medium: 20,
+        low: 10,
+    };
+    return severityPoints[severity] ?? 10;
+}
+/**
+ * Compute points based on days since last review
+ * +1 point per day, capped at 30 points
+ */
+function computeStalenessPoints(lastReviewed) {
+    const daysSince = Math.floor((Date.now() - lastReviewed.getTime()) / (1000 * 60 * 60 * 24));
+    return Math.min(daysSince, 30);
+}
+/**
+ * Check if an item is overdue for review
+ */
+function isOverdue(nextReview) {
+    return new Date(nextReview) < new Date();
+}
+/**
+ * Check if any linked blueprints are actively in progress
+ */
+function hasActiveBlueprintLink(linkedBlueprints) {
+    return linkedBlueprints.some((bp) => bp.status === 'in-progress');
+}
+/**
+ * Compute points based on category urgency
+ * Security=5, Testing=3, Others=0
+ */
+function computeCategoryPoints(category) {
+    const categoryPoints = {
+        security: 5,
+        testing: 3,
+    };
+    return categoryPoints[category] ?? 0;
+}
+//# sourceMappingURL=priority-scoring.js.map

package/dist/esm/blueprint/service/scanner.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Plan Directory Scanner
+ *
+ * Recursively scans the blueprint directory to discover all plan _overview.md files.
+ * Handles various directory structures including group/initiative, standalone, and special folders.
+ */
+/**
+ * Represents a scanned plan with path and metadata extracted from directory structure.
+ */
+export interface ScannedBlueprint {
+    /** Full absolute path to the _overview.md file */
+    path: string;
+    /** Slug derived from directory structure (e.g., 'in-progress/schema-driven-admin-ui-permissions') */
+    slug: string;
+    /** Parent group (e.g., 'in-progress', 'completed'), null for standalone plans */
+    group: string | null;
+    /** True if the plan is in a special folder (_completed, _future, _deprioritized) */
+    isSpecialFolder: boolean;
+    /** Type of special folder if isSpecialFolder is true */
+    specialFolderType?: '_completed' | '_future' | '_deprioritized';
+}
+/**
+ * Options for scanning the plan directory.
+ */
+export interface ScanOptions {
+    /** Base directory to scan (default: 'webpresso/blueprints') */
+    baseDir?: string;
+    /** Include plans in special folders (_completed, _future, _deprioritized) (default: false) */
+    includeSpecialFolders?: boolean;
+}
+/**
+ * Generic options for scanning any document directory.
+ */
+export interface GenericScanOptions {
+    /** Base directory to scan (relative to monorepo root or absolute) */
+    baseDir: string;
+    /** File pattern to match (e.g., '_overview.md', '_task.md') */
+    filePattern: string;
+    /** Include files in special folders (_completed, _future, _deprioritized) (default: false) */
+    includeSpecialFolders?: boolean;
+}
+/**
+ * Generic function to scan any document directory with a specified file pattern.
+ *
+ * @param options - Generic scan configuration options with baseDir and filePattern
+ * @returns Array of scanned documents with path and metadata
+ */
+export declare function scanDocumentDirectory(options: GenericScanOptions): ScannedBlueprint[];
+/**
+ * Scan the blueprint directory for all plan _overview.md files.
+ *
+ * @param options - Scan configuration options
+ * @returns Array of scanned plans with path and metadata
+ */
+export declare function scanBlueprintDirectory(options?: ScanOptions): ScannedBlueprint[];
+//# sourceMappingURL=scanner.d.ts.map

package/dist/esm/blueprint/service/scanner.js

@@ -0,0 +1,212 @@
+/**
+ * Plan Directory Scanner
+ *
+ * Recursively scans the blueprint directory to discover all plan _overview.md files.
+ * Handles various directory structures including group/initiative, standalone, and special folders.
+ */
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { resolveBlueprintRoot } from '#utils/blueprint-root';
+/** Special folder prefixes that indicate archived/deferred plans */
+const SPECIAL_FOLDERS = ['_completed', '_future', '_deprioritized'];
+/** Standard plan overview filename */
+const OVERVIEW_FILENAME = '_overview.md';
+/**
+ * Check if a path component is a special folder.
+ */
+function isSpecialFolder(name) {
+    return SPECIAL_FOLDERS.includes(name);
+}
+/**
+ * Find the special folder type in a path, if any.
+ */
+function findSpecialFolderType(pathSegments) {
+    for (const segment of pathSegments) {
+        if (isSpecialFolder(segment)) {
+            return segment;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract the slug and group from a plan path.
+ *
+ * Examples:
+ * - 'webpresso/blueprints/agile-workflows/git-task-store/_overview.md'
+ *   -> slug: 'agile-workflows/git-task-store', group: 'agile-workflows'
+ * - 'webpresso/blueprints/documentation-governance/_overview.md'
+ *   -> slug: 'documentation-governance', group: null
+ * - 'webpresso/blueprints/_completed/old-plan/_overview.md'
+ *   -> slug: '_completed/old-plan', group: null (special folder)
+ */
+function extractSlugAndGroup(fullPath, baseDir, filePattern = OVERVIEW_FILENAME) {
+    // Get relative path from base directory
+    const relPath = relative(baseDir, fullPath);
+    // Split into segments and remove the document filename
+    const segments = relPath.split('/').filter((s) => s !== filePattern && s !== '');
+    if (!segments.length) {
+        return { slug: '', group: null };
+    }
+    // Filter out special folders from the slug calculation for group determination
+    const nonSpecialSegments = segments.filter((s) => !isSpecialFolder(s));
+    // The slug is the full path (including special folders)
+    const slug = segments.join('/');
+    // Determine group:
+    // - If we have 2+ non-special segments, first non-special is the group
+    // - If we have 1 non-special segment, it's a standalone (group = null)
+    // - Special folders at root don't count as groups
+    let group = null;
+    // Find the first non-special segment
+    const firstNonSpecialIndex = segments.findIndex((s) => !isSpecialFolder(s));
+    if (firstNonSpecialIndex >= 0 && nonSpecialSegments.length >= 2) {
+        // There's a group structure: first non-special segment is the group
+        group = segments[firstNonSpecialIndex] ?? null;
+    }
+    return { slug, group };
+}
+/**
+ * Check if an entry should be skipped during directory traversal.
+ */
+function shouldSkipEntry(entry) {
+    return entry.startsWith('.') || entry === 'node_modules';
+}
+/**
+ * Safely get file stats, returning null on error.
+ */
+function safeStatSync(fullPath) {
+    try {
+        return statSync(fullPath);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Process a _overview.md file and create a ScannedBlueprint if applicable.
+ */
+/**
+ * Get valid directory entries, filtering out hidden and node_modules.
+ */
+function getValidEntries(dir) {
+    try {
+        return readdirSync(dir).filter((entry) => !shouldSkipEntry(entry));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if a relative path contains hidden directory components (segments starting with '.').
+ */
+function containsHiddenDirectory(relativePath) {
+    const segments = relativePath.split('/');
+    return segments.some((segment) => segment.startsWith('.') && segment !== '' && segment !== '.');
+}
+/**
+ * Process a single directory entry and update results/queue.
+ */
+function processEntry(entry, dir, baseDir, filePattern, includeSpecialFolders, results, queue) {
+    const fullPath = join(dir, entry);
+    const stat = safeStatSync(fullPath);
+    if (!stat)
+        return;
+    if (stat.isDirectory()) {
+        // Skip directories if the relative path from baseDir contains hidden directory components
+        const relativePath = relative(baseDir, fullPath);
+        if (!containsHiddenDirectory(relativePath)) {
+            queue.push(fullPath);
+        }
+        return;
+    }
+    // Only accept files matching the pattern
+    if (entry === filePattern) {
+        const plan = processPlanFile(fullPath, baseDir, includeSpecialFolders, filePattern);
+        if (plan) {
+            results.push(plan);
+        }
+        return;
+    }
+}
+/**
+ * Process a plan file (_overview.md or _overview.md) and create a ScannedBlueprint if applicable.
+ */
+function processPlanFile(fullPath, baseDir, includeSpecialFolders, filePattern = OVERVIEW_FILENAME) {
+    const relativePath = relative(baseDir, fullPath);
+    // Skip files in hidden directories (defense-in-depth check)
+    if (containsHiddenDirectory(relativePath)) {
+        return null;
+    }
+    const pathSegments = relativePath.split('/');
+    const specialFolderType = findSpecialFolderType(pathSegments);
+    const isInSpecialFolder = specialFolderType !== undefined;
+    // Skip special folders unless explicitly included
+    if (isInSpecialFolder && !includeSpecialFolders) {
+        return null;
+    }
+    const { slug, group } = extractSlugAndGroup(fullPath, baseDir, filePattern);
+    const scannedPlan = {
+        path: fullPath,
+        slug,
+        group,
+        isSpecialFolder: isInSpecialFolder,
+    };
+    if (specialFolderType) {
+        scannedPlan.specialFolderType = specialFolderType;
+    }
+    return scannedPlan;
+}
+/**
+ * Scan directories iteratively using a queue (avoids recursion complexity).
+ */
+function scanDirectory(startDir, baseDir, filePattern, includeSpecialFolders, results) {
+    const queue = [startDir];
+    while (queue.length > 0) {
+        const dir = queue.shift();
+        if (!dir)
+            continue;
+        const entries = getValidEntries(dir);
+        for (const entry of entries) {
+            processEntry(entry, dir, baseDir, filePattern, includeSpecialFolders, results, queue);
+        }
+    }
+}
+/**
+ * Generic function to scan any document directory with a specified file pattern.
+ *
+ * @param options - Generic scan configuration options with baseDir and filePattern
+ * @returns Array of scanned documents with path and metadata
+ */
+export function scanDocumentDirectory(options) {
+    const { baseDir, filePattern, includeSpecialFolders = false } = options;
+    let absoluteBaseDir;
+    if (isAbsolute(baseDir)) {
+        // Already absolute, use as-is
+        absoluteBaseDir = baseDir;
+    }
+    else {
+        // Relative path - resolve from cwd
+        absoluteBaseDir = resolve(process.cwd(), baseDir);
+    }
+    if (!existsSync(absoluteBaseDir)) {
+        return [];
+    }
+    const results = [];
+    scanDirectory(absoluteBaseDir, absoluteBaseDir, filePattern, includeSpecialFolders, results);
+    return results;
+}
+/**
+ * Scan the blueprint directory for all plan _overview.md files.
+ *
+ * @param options - Scan configuration options
+ * @returns Array of scanned plans with path and metadata
+ */
+export function scanBlueprintDirectory(options) {
+    const baseDir = options?.baseDir ?? resolveBlueprintRoot();
+    const includeSpecialFolders = options?.includeSpecialFolders ?? false;
+    return scanDocumentDirectory({
+        baseDir,
+        filePattern: OVERVIEW_FILENAME,
+        includeSpecialFolders,
+    });
+}
+//# sourceMappingURL=scanner.js.map

package/dist/esm/blueprint/sync/auth.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Credential loading for the BlueprintSyncClient.
+ *
+ * Reads configuration from environment variables; never writes to disk.
+ *
+ * Environment variables:
+ *   WP_BLUEPRINT_PLATFORM_DISABLED  — set to "1" to bypass all platform ops
+ *   WP_BLUEPRINT_PLATFORM_TOKEN     — required Bearer token
+ *   WP_BLUEPRINT_PLATFORM_URL       — override API base URL (default: https://api.webpresso.io)
+ */
+export interface SyncCredentials {
+    readonly token: string;
+    readonly platformUrl: string;
+    readonly repoId: string;
+}
+/**
+ * Load sync credentials from the environment.
+ *
+ * Returns `null` when:
+ *  - `WP_BLUEPRINT_PLATFORM_DISABLED=1` (emergency escape hatch), or
+ *  - `WP_BLUEPRINT_PLATFORM_TOKEN` is not set or is an empty string.
+ *
+ * The caller must treat `null` as "sync is unavailable" and bypass all
+ * platform operations.
+ */
+export declare function loadSyncCredentials(): SyncCredentials | null;
+//# sourceMappingURL=auth.d.ts.map

package/dist/esm/blueprint/sync/auth.js

@@ -0,0 +1,59 @@
+/**
+ * Credential loading for the BlueprintSyncClient.
+ *
+ * Reads configuration from environment variables; never writes to disk.
+ *
+ * Environment variables:
+ *   WP_BLUEPRINT_PLATFORM_DISABLED  — set to "1" to bypass all platform ops
+ *   WP_BLUEPRINT_PLATFORM_TOKEN     — required Bearer token
+ *   WP_BLUEPRINT_PLATFORM_URL       — override API base URL (default: https://api.webpresso.io)
+ */
+import { createHash } from 'node:crypto';
+import { execSync } from 'node:child_process';
+const DEFAULT_PLATFORM_URL = 'https://api.webpresso.io';
+/**
+ * Derive a stable, opaque repo identifier from the git remote origin URL.
+ *
+ * Falls back to a hash of the CWD when git is unavailable (e.g. in tests
+ * where there is no remote). The returned value is a lowercase hex string.
+ */
+function deriveRepoId() {
+    let input;
+    try {
+        const remote = execSync('git remote get-url origin', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        input = remote.length > 0 ? remote : process.cwd();
+    }
+    catch {
+        input = process.cwd();
+    }
+    return createHash('sha256').update(input).digest('hex');
+}
+/**
+ * Load sync credentials from the environment.
+ *
+ * Returns `null` when:
+ *  - `WP_BLUEPRINT_PLATFORM_DISABLED=1` (emergency escape hatch), or
+ *  - `WP_BLUEPRINT_PLATFORM_TOKEN` is not set or is an empty string.
+ *
+ * The caller must treat `null` as "sync is unavailable" and bypass all
+ * platform operations.
+ */
+export function loadSyncCredentials() {
+    if (process.env['WP_BLUEPRINT_PLATFORM_DISABLED'] === '1') {
+        return null;
+    }
+    const token = process.env['WP_BLUEPRINT_PLATFORM_TOKEN'] ?? '';
+    if (token.length === 0) {
+        return null;
+    }
+    const platformUrl = process.env['WP_BLUEPRINT_PLATFORM_URL'] ?? DEFAULT_PLATFORM_URL;
+    return {
+        token,
+        platformUrl,
+        repoId: deriveRepoId(),
+    };
+}
+//# sourceMappingURL=auth.js.map