@webpresso/agent-kit 0.21.0

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

@@ -0,0 +1,260 @@
+import { existsSync } from 'node:fs';
+import { mkdtemp, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parseBlueprint } from '#core/parser';
+import { scanBlueprintDirectory } from '#service/scanner';
+import { resolveBlueprintRoot } from '#utils/blueprint-root';
+import { resolvePackageAsset } from '#utils/package-assets';
+const RESERVED_BLUEPRINT_SLUGS = new Set([
+    'draft',
+    'planned',
+    'parked',
+    'in-progress',
+    'completed',
+    'archived',
+]);
+const DEFAULT_TEMPLATE_PATH = resolvePackageAsset('docs/templates/blueprint.md');
+function formatDate(date) {
+    return date.toISOString().split('T')[0] ?? date.toISOString();
+}
+function replacePlaceholder(template, placeholder, value) {
+    return template.split(placeholder).join(value);
+}
+function toPortableRelativePath(projectRoot, absolutePath) {
+    return path.relative(projectRoot, absolutePath).replaceAll(path.sep, '/');
+}
+function normalizeGoal(goal) {
+    const normalized = goal.trim().replace(/\s+/g, ' ');
+    if (normalized.length === 0) {
+        throw new Error('Blueprint goal must not be empty or whitespace.');
+    }
+    return normalized;
+}
+function sentenceCase(value) {
+    if (value.length === 0) {
+        return value;
+    }
+    return value.slice(0, 1).toUpperCase() + value.slice(1);
+}
+function deriveSlug(goal) {
+    return goal
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-{2,}/g, '-');
+}
+function assertGoalProducesUsableSlug(goal, slug) {
+    if (slug.length === 0) {
+        throw new Error(`Blueprint goal "${goal}" could not be converted into a valid slug.`);
+    }
+    if (RESERVED_BLUEPRINT_SLUGS.has(slug)) {
+        throw new Error(`Blueprint goal "${goal}" resolves to reserved slug "${slug}".`);
+    }
+}
+function prepareTemplate(template) {
+    const sanitized = template.replace(/^> \*\*For Claude:\*\*.*(?:\r?\n)?/gm, '');
+    const withFrontmatterPlaceholders = sanitized
+        .replace(/^complexity:\s*.+$/m, 'complexity: {{complexity}}')
+        .replace(/^created:\s*.+$/m, "created: '{{date}}'")
+        .replace(/^last_updated:\s*.+$/m, "last_updated: '{{date}}'");
+    if (withFrontmatterPlaceholders.includes('## Planning Summary')) {
+        return withFrontmatterPlaceholders;
+    }
+    return withFrontmatterPlaceholders.replace(/\*\*Goal:\*\*\s*\{\{description\}\}/, [
+        '**Goal:** {{description}}',
+        '',
+        '## Planning Summary',
+        '',
+        '- Goal input: `{{description}}`',
+        '- Complexity: `{{complexity}}`',
+        '- Draft slug: `{{slug}}`',
+        '- Output path: `{{output_path}}`',
+        '- Generated command: `wp blueprint new "{{description}}" --complexity {{complexity}}`',
+        '- Validation scope: parser compliance before write',
+    ].join('\n'));
+}
+function buildParentRoadmapMarkdown(input) {
+    return [
+        '---',
+        'type: parent-roadmap',
+        'status: draft',
+        `complexity: ${input.complexity}`,
+        `created: '${input.date}'`,
+        `last_updated: '${input.date}'`,
+        '---',
+        '',
+        `# ${input.title}`,
+        '',
+        `**Goal:** ${input.goal}`,
+        '',
+        '## Planning Summary',
+        '',
+        `- Goal input: \`${input.goal}\``,
+        `- Complexity: \`${input.complexity}\``,
+        `- Draft slug: \`${input.slug}\``,
+        `- Output path: \`${input.outputPath}\``,
+        `- Creation command: \`wp blueprint new "${input.goal}" --complexity ${input.complexity} --type parent-roadmap\``,
+        '',
+        '## Architecture Overview',
+        '',
+        '- Parent roadmap scaffold. Add child blueprints and sequencing after creation.',
+        '',
+        '## Verification Gates',
+        '',
+        '- Parses as `type: parent-roadmap`.',
+        '- Surfaces in roadmap-aware list/show commands.',
+        '',
+    ].join('\n');
+}
+function validateGeneratedDraft(markdown, slug, type) {
+    let blueprint;
+    try {
+        blueprint = parseBlueprint(markdown, slug);
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : 'Generated blueprint failed parser validation.',
+            valid: false,
+        };
+    }
+    const missingSections = [
+        '## Planning Summary',
+        '## Architecture Overview',
+        '## Verification Gates',
+    ].filter((section) => !markdown.includes(section));
+    if (missingSections.length > 0) {
+        return {
+            error: `Generated blueprint is missing required section(s): ${missingSections.join(', ')}`,
+            valid: false,
+        };
+    }
+    if (type === 'blueprint' && blueprint.tasks.length === 0) {
+        return {
+            error: 'Generated blueprint must include at least one executable task.',
+            valid: false,
+        };
+    }
+    return {
+        blueprint,
+        valid: true,
+    };
+}
+export class BlueprintCreationService {
+    now;
+    projectRoot;
+    blueprintsRoot;
+    templatePath;
+    constructor(projectRootOrOptions, options = {}) {
+        const resolvedProjectRoot = typeof projectRootOrOptions === 'string'
+            ? projectRootOrOptions
+            : projectRootOrOptions.projectRoot;
+        const resolvedOptions = typeof projectRootOrOptions === 'string' ? options : projectRootOrOptions;
+        this.projectRoot = resolvedProjectRoot;
+        this.blueprintsRoot = resolveBlueprintRoot(resolvedProjectRoot);
+        this.templatePath = resolvedOptions.templatePath ?? DEFAULT_TEMPLATE_PATH;
+        this.now = resolvedOptions.now ?? (() => new Date());
+    }
+    async compile(input) {
+        return this.compileDraft(input);
+    }
+    async compileDraft(input) {
+        const goal = normalizeGoal(input.goal);
+        const type = input.type ?? 'blueprint';
+        const baseSlug = deriveSlug(goal);
+        assertGoalProducesUsableSlug(goal, baseSlug);
+        const slug = this.resolveCollisionSafeSlug(baseSlug);
+        const title = sentenceCase(goal);
+        const outputPath = path.join(this.blueprintsRoot, 'draft', slug, '_overview.md');
+        const relativeFilePath = toPortableRelativePath(this.projectRoot, outputPath);
+        const date = formatDate(this.now());
+        const template = type === 'blueprint' ? prepareTemplate(await readFile(this.templatePath, 'utf-8')) : undefined;
+        const markdown = type === 'parent-roadmap'
+            ? buildParentRoadmapMarkdown({
+                complexity: input.complexity,
+                date,
+                goal,
+                outputPath: relativeFilePath,
+                slug,
+                title,
+            })
+            : [
+                ['{{date}}', date],
+                ['{{complexity}}', input.complexity],
+                ['{{title}}', title],
+                ['{{description}}', goal],
+                ['{{slug}}', slug],
+                ['{{output_path}}', relativeFilePath],
+            ].reduce((currentTemplate, [placeholder, value]) => replacePlaceholder(currentTemplate, placeholder, value), template ?? '');
+        parseBlueprint(markdown, slug);
+        return {
+            complexity: input.complexity,
+            markdown,
+            outputPath,
+            path: outputPath,
+            projectRoot: this.projectRoot,
+            relativeFilePath,
+            slug,
+            status: 'draft',
+            title,
+            type,
+        };
+    }
+    async create(input) {
+        const draft = await this.compileDraft(input);
+        const draftRoot = path.join(this.blueprintsRoot, 'draft');
+        const finalDir = path.dirname(draft.outputPath);
+        await mkdir(draftRoot, { recursive: true });
+        await mkdir(path.dirname(finalDir), { recursive: true });
+        const tempDir = await mkdtemp(path.join(draftRoot, `${draft.slug}.tmp-`));
+        const tempPath = path.join(tempDir, '_overview.md');
+        try {
+            await writeFile(tempPath, draft.markdown, 'utf-8');
+            const writtenMarkdown = await readFile(tempPath, 'utf-8');
+            const validation = validateGeneratedDraft(writtenMarkdown, draft.slug, draft.type);
+            if (!validation.valid || !validation.blueprint) {
+                throw new Error(validation.error ?? 'Generated blueprint failed validation.');
+            }
+            await rename(tempDir, finalDir);
+            return {
+                ...draft,
+                blueprint: validation.blueprint,
+            };
+        }
+        catch (error) {
+            await rm(tempDir, { force: true, recursive: true });
+            await removeIfEmpty(draftRoot);
+            throw error;
+        }
+    }
+    resolveCollisionSafeSlug(baseSlug) {
+        const blueprintsRoot = this.blueprintsRoot;
+        const existing = new Set(scanBlueprintDirectory({
+            baseDir: blueprintsRoot,
+            includeSpecialFolders: true,
+        }).map((entry) => entry.slug.split('/').slice(1).join('/') || entry.slug));
+        if (!existing.has(baseSlug) && !blueprintDirectoryExists(blueprintsRoot, baseSlug)) {
+            return baseSlug;
+        }
+        let suffix = 2;
+        while (existing.has(`${baseSlug}-${suffix}`) ||
+            blueprintDirectoryExists(blueprintsRoot, `${baseSlug}-${suffix}`)) {
+            suffix += 1;
+        }
+        return `${baseSlug}-${suffix}`;
+    }
+}
+function blueprintDirectoryExists(blueprintsRoot, slug) {
+    return [...RESERVED_BLUEPRINT_SLUGS].some((status) => existsSync(path.join(blueprintsRoot, status, slug)));
+}
+async function removeIfEmpty(directory) {
+    try {
+        const entries = await readdir(directory);
+        if (entries.length === 0) {
+            await rm(directory, { force: true, recursive: true });
+        }
+    }
+    catch {
+        // Best-effort cleanup only.
+    }
+}
+//# sourceMappingURL=BlueprintCreationService.js.map

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

@@ -0,0 +1,70 @@
+/**
+ * Plan Service
+ *
+ * Manages implementation plans stored in git.
+ * Scans resolved blueprint roots recursively for _overview.md files.
+ */
+import type { BlueprintLifecycleIntent } from '#lifecycle/engine';
+import type { BlueprintQueryFilters, BlueprintQueryResult, BlueprintRecord, BlueprintSortOptions } from '#query/types';
+import type { TechDebtRecord } from '#tech-debt/index';
+import { type Blueprint } from '#core/parser';
+import { TrackedDocumentService } from './TrackedDocumentService.js';
+export interface BlueprintSummary {
+    name: string;
+    title: string;
+    status: string;
+    complexity: string;
+    taskCount: number;
+    progress: number;
+    type: 'blueprint' | 'parent-roadmap';
+    parentRoadmap?: string;
+    malformed?: string;
+}
+export interface BlueprintQueryOptions {
+    filters?: BlueprintQueryFilters;
+    sort?: BlueprintSortOptions;
+    limit?: number;
+    offset?: number;
+}
+export declare class BlueprintService extends TrackedDocumentService<BlueprintSummary, BlueprintRecord, BlueprintQueryFilters, BlueprintSortOptions, BlueprintQueryResult> {
+    constructor(projectPath?: string);
+    list(): Promise<BlueprintSummary[]>;
+    private tryParseBlueprintSummary;
+    protected parseSummary(content: string, slug: string): BlueprintSummary;
+    protected buildMalformedSummary(scanned: {
+        path: string;
+        slug: string;
+    }, data: Record<string, unknown>, errorMessage: string): BlueprintSummary;
+    get(slug: string): Promise<Blueprint>;
+    query(options?: BlueprintQueryOptions): Promise<BlueprintQueryResult>;
+    getStalePlans(thresholdDays?: number): Promise<BlueprintRecord[]>;
+    getByGroup(group: string): Promise<BlueprintRecord[]>;
+    protected toRecord(filePath: string, slug: string, group: string | null): Promise<BlueprintRecord | null>;
+    protected matchesAllFilters(plan: BlueprintRecord, filters: BlueprintQueryFilters): boolean;
+    protected applySorting(plans: BlueprintRecord[], sort: BlueprintSortOptions): BlueprintRecord[];
+    private computeQuerySummary;
+    /**
+     * Link a blueprint to a tech debt item (bidirectional)
+     * Updates both the blueprint document and tech debt frontmatter
+     * @param bpSlug - Blueprint slug
+     * @param tdSlug - TechDebt slug
+     * @throws Error if blueprint doesn't exist
+     */
+    linkToTechDebt(bpSlug: string, tdSlug: string): Promise<void>;
+    /**
+     * Unlink a blueprint from a tech debt item (bidirectional)
+     * Updates both the blueprint document and tech debt frontmatter
+     * @param bpSlug - Blueprint slug
+     * @param tdSlug - TechDebt slug
+     */
+    unlinkFromTechDebt(bpSlug: string, tdSlug: string): Promise<void>;
+    /**
+     * Get all tech debt items linked to a blueprint
+     * @param bpSlug - Blueprint slug
+     * @returns Array of TechDebtRecord objects
+     */
+    getLinkedTechDebt(bpSlug: string): Promise<TechDebtRecord[]>;
+    moveBlueprint(slug: string, targetStatus: string): Promise<void>;
+    updateBlueprintStatus(slug: string, intent: BlueprintLifecycleIntent): Promise<void>;
+}
+//# sourceMappingURL=BlueprintService.d.ts.map

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

@@ -0,0 +1,190 @@
+/**
+ * Plan Service
+ *
+ * Manages implementation plans stored in git.
+ * Scans resolved blueprint roots recursively for _overview.md files.
+ */
+import matter from 'gray-matter';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parseBlueprint } from '#core/parser';
+import { applyBlueprintLifecycleToFile } from '#lifecycle/local';
+import { resolveBlueprintRoot } from '#utils/blueprint-root';
+import { emitTraceArtifact, generateBlueprintLifecycleTrace } from '#utils/decision-trace-artifacts';
+import { BlueprintNotFoundError } from '#utils/errors';
+import { computeBlueprintQuerySummary, matchesBlueprintFilters, sortBlueprintRecords, toBlueprintRecord, } from './blueprint-records.js';
+import { linkBlueprintToTechDebt, unlinkBlueprintFromTechDebt, } from './blueprint-tech-debt-links.js';
+import { scanBlueprintDirectory } from './scanner.js';
+import { TechDebtService } from './TechDebtService.js';
+import { TrackedDocumentService } from './TrackedDocumentService.js';
+export class BlueprintService extends TrackedDocumentService {
+    constructor(projectPath) {
+        // Resolve generic consumer layout first, with Webpresso's legacy layout as fallback.
+        const plansDir = resolveBlueprintRoot(projectPath);
+        super(plansDir, '_overview.md', projectPath);
+    }
+    async list() {
+        const scannedPlans = scanBlueprintDirectory({
+            baseDir: this.baseDir,
+            includeSpecialFolders: true,
+        });
+        const plans = [];
+        for (const scanned of scannedPlans) {
+            const summary = await this.tryParseBlueprintSummary(scanned);
+            if (summary) {
+                plans.push(summary);
+            }
+        }
+        return plans;
+    }
+    async tryParseBlueprintSummary(scanned) {
+        try {
+            const content = await fs.readFile(scanned.path, 'utf-8');
+            return this.parseSummary(content, scanned.slug);
+        }
+        catch (error) {
+            return this.handleParseSummaryError(error, scanned);
+        }
+    }
+    parseSummary(content, slug) {
+        const plan = parseBlueprint(content, slug);
+        const doneCount = plan.tasks.filter((t) => t.status === 'done').length;
+        return {
+            name: plan.name,
+            title: plan.title,
+            status: plan.status,
+            complexity: plan.complexity,
+            taskCount: plan.tasks.length,
+            progress: plan.tasks.length > 0 ? Math.round((doneCount / plan.tasks.length) * 100) : 0,
+            type: plan.type,
+            ...(plan.parentRoadmap ? { parentRoadmap: plan.parentRoadmap } : {}),
+        };
+    }
+    buildMalformedSummary(scanned, data, errorMessage) {
+        return {
+            name: scanned.slug,
+            title: scanned.slug,
+            status: data.status || 'unknown',
+            complexity: data.complexity || 'unknown',
+            taskCount: 0,
+            progress: 0,
+            type: data.type === 'parent-roadmap' ? 'parent-roadmap' : 'blueprint',
+            malformed: errorMessage,
+        };
+    }
+    async get(slug) {
+        // Try direct path first (supports both 'in-progress/foo' and 'foo')
+        const planPath = path.join(this.baseDir, slug, '_overview.md');
+        try {
+            await fs.access(planPath);
+            const content = await fs.readFile(planPath, 'utf-8');
+            return parseBlueprint(content, slug);
+        }
+        catch {
+            // Scan all plans to find a match by slug
+            const scannedPlans = scanBlueprintDirectory({
+                baseDir: this.baseDir,
+                includeSpecialFolders: true,
+            });
+            const found = scannedPlans.find((p) => p.slug === slug || p.slug.endsWith(`/${slug}`));
+            if (!found) {
+                throw new BlueprintNotFoundError(slug, planPath, scannedPlans.map((p) => p.slug));
+            }
+            const content = await fs.readFile(found.path, 'utf-8');
+            return parseBlueprint(content, found.slug);
+        }
+    }
+    async query(options) {
+        const scannedPlans = scanBlueprintDirectory({ baseDir: this.baseDir });
+        const planRecords = await this.buildRecords(scannedPlans);
+        const { records, totalFiltered } = this.processQueryPipeline(planRecords, options);
+        return {
+            plans: records,
+            summary: this.computeQuerySummary(planRecords, totalFiltered),
+        };
+    }
+    async getStalePlans(thresholdDays) {
+        const result = await this.query({
+            filters: { stale: true, staleDays: thresholdDays },
+        });
+        return result.plans;
+    }
+    async getByGroup(group) {
+        const result = await this.query({
+            filters: { group },
+        });
+        return result.plans;
+    }
+    async toRecord(filePath, slug, group) {
+        return toBlueprintRecord(filePath, slug, group);
+    }
+    matchesAllFilters(plan, filters) {
+        return matchesBlueprintFilters(plan, filters, (value, filter) => this.matchesFilter(value, filter));
+    }
+    applySorting(plans, sort) {
+        return sortBlueprintRecords(plans, sort);
+    }
+    // Compute query summary (different from list summary)
+    computeQuerySummary(allPlans, totalFiltered) {
+        return computeBlueprintQuerySummary(allPlans, totalFiltered, (records, selector) => this.countByField(records, selector), (plan) => this.isStale(plan));
+    }
+    /**
+     * Link a blueprint to a tech debt item (bidirectional)
+     * Updates both the blueprint document and tech debt frontmatter
+     * @param bpSlug - Blueprint slug
+     * @param tdSlug - TechDebt slug
+     * @throws Error if blueprint doesn't exist
+     */
+    async linkToTechDebt(bpSlug, tdSlug) {
+        await linkBlueprintToTechDebt(this.baseDir, this.projectPath, bpSlug, tdSlug);
+    }
+    /**
+     * Unlink a blueprint from a tech debt item (bidirectional)
+     * Updates both the blueprint document and tech debt frontmatter
+     * @param bpSlug - Blueprint slug
+     * @param tdSlug - TechDebt slug
+     */
+    async unlinkFromTechDebt(bpSlug, tdSlug) {
+        await unlinkBlueprintFromTechDebt(this.baseDir, this.projectPath, bpSlug, tdSlug);
+    }
+    /**
+     * Get all tech debt items linked to a blueprint
+     * @param bpSlug - Blueprint slug
+     * @returns Array of TechDebtRecord objects
+     */
+    async getLinkedTechDebt(bpSlug) {
+        const blueprintPath = path.join(this.baseDir, bpSlug, '_overview.md');
+        const content = await fs.readFile(blueprintPath, 'utf-8');
+        const parsed = matter(content);
+        const data = JSON.parse(JSON.stringify(parsed.data));
+        const linkedTechDebtSlugs = data.linked_tech_debt_slugs ?? [];
+        if (!linkedTechDebtSlugs.length) {
+            return [];
+        }
+        const techDebtService = new TechDebtService(this.projectPath);
+        const allTechDebt = await techDebtService.query();
+        return allTechDebt.items.filter((techDebt) => linkedTechDebtSlugs.includes(techDebt.slug));
+    }
+    async moveBlueprint(slug, targetStatus) {
+        const projectRoot = this.projectPath ?? process.cwd();
+        const intent = targetStatus === 'completed' ? { type: 'finalize' } : { type: 'start' };
+        const result = await applyBlueprintLifecycleToFile(projectRoot, slug, intent);
+        const trace = generateBlueprintLifecycleTrace(slug, 'move', {
+            from: slug,
+            to: `${result.targetStatus}/${slug}`,
+            moved: result.moved,
+        });
+        emitTraceArtifact(projectRoot, trace);
+    }
+    async updateBlueprintStatus(slug, intent) {
+        const projectRoot = this.projectPath ?? process.cwd();
+        const result = await applyBlueprintLifecycleToFile(projectRoot, slug, intent);
+        const trace = generateBlueprintLifecycleTrace(slug, 'status_change', {
+            intent: intent.type,
+            targetStatus: result.targetStatus,
+            moved: result.moved,
+        });
+        emitTraceArtifact(projectRoot, trace);
+    }
+}
+//# sourceMappingURL=BlueprintService.js.map

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

@@ -0,0 +1,102 @@
+/**
+ * TechDebtService
+ *
+ * Manages technical debt items stored in git.
+ * Scans tech-debt documents recursively from the resolved repo layout.
+ * Extends TrackedDocumentService to provide filtering, sorting, and query capabilities.
+ */
+import type { BlueprintRecord } from '#query/types';
+import { type TechDebtItem, type TechDebtQueryFilters, type TechDebtQueryResult, type TechDebtRecord, type TechDebtSortOptions } from '#tech-debt/index';
+import { TrackedDocumentService } from './TrackedDocumentService.js';
+export interface TechDebtSummary {
+    slug: string;
+    title: string;
+    status: string;
+    severity: string;
+    category?: string;
+    priorityScore: number;
+    nextReview?: string;
+    malformed?: string;
+}
+export interface TechDebtQueryOptions {
+    filters?: TechDebtQueryFilters;
+    sort?: TechDebtSortOptions;
+    limit?: number;
+    offset?: number;
+}
+export declare class TechDebtService extends TrackedDocumentService<TechDebtSummary, TechDebtRecord, TechDebtQueryFilters, TechDebtSortOptions, TechDebtQueryResult> {
+    constructor(projectPath?: string);
+    list(): Promise<TechDebtSummary[]>;
+    listTechDebt(): Promise<TechDebtSummary[]>;
+    private tryParseTechDebtSummary;
+    protected parseSummary(content: string, slug: string): TechDebtSummary;
+    protected buildMalformedSummary(scanned: {
+        path: string;
+        slug: string;
+    }, data: Record<string, unknown>, errorMessage: string): TechDebtSummary;
+    get(slug: string): Promise<TechDebtItem>;
+    getTechDebt(slug: string): Promise<TechDebtItem>;
+    query(options?: TechDebtQueryOptions): Promise<TechDebtQueryResult>;
+    /**
+     * Get tech debt items that are past their review date
+     */
+    getOverdueReviews(): Promise<TechDebtRecord[]>;
+    /**
+     * Get tech debt items by category
+     */
+    getByCategory(category: string): Promise<TechDebtRecord[]>;
+    /**
+     * Get tech debt items by severity
+     */
+    getBySeverity(severity: string): Promise<TechDebtRecord[]>;
+    /**
+     * Link a tech debt item to a blueprint (bidirectional)
+     * Updates both the tech debt document and blueprint frontmatter
+     * @param tdSlug - TechDebt slug
+     * @param bpSlug - Blueprint slug
+     * @throws Error if either document doesn't exist
+     */
+    linkToBlueprint(tdSlug: string, bpSlug: string): Promise<void>;
+    /**
+     * Unlink a tech debt item from a blueprint (bidirectional)
+     * Updates both the tech debt document and blueprint frontmatter
+     * @param tdSlug - TechDebt slug
+     * @param bpSlug - Blueprint slug
+     */
+    unlinkFromBlueprint(tdSlug: string, bpSlug: string): Promise<void>;
+    /**
+     * Get all blueprints linked to a tech debt item
+     * @param tdSlug - TechDebt slug
+     * @returns Array of BlueprintRecord objects
+     */
+    getLinkedBlueprints(tdSlug: string): Promise<BlueprintRecord[]>;
+    /**
+     * Compute priority score for a tech debt item
+     *
+     * Calculates a 0-100 priority score based on:
+     * - Severity (10-40 points)
+     * - Staleness (0-30 points) - days since last review
+     * - Overdue review (0-20 points)
+     * - Active blueprint link (0-10 points)
+     * - Category urgency (0-5 points) - security=5, testing=3
+     *
+     * @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)
+     */
+    computePriorityScore(item: TechDebtRecord, linkedBlueprints: BlueprintRecord[]): number;
+    private static readonly FRESHNESS_STATUS_MAP;
+    private static computeFreshness;
+    protected toRecord(filePath: string, slug: string, group: string | null): Promise<TechDebtRecord | null>;
+    protected matchesAllFilters(item: TechDebtRecord, filters: TechDebtQueryFilters): boolean;
+    private matchesSeverityFilter;
+    private matchesCategoryFilter;
+    private matchesOverdueFilter;
+    private matchesStaleDaysFilter;
+    private static readonly SEVERITY_ORDER;
+    private static compareOptionalDates;
+    private static compareField;
+    protected applySorting(items: TechDebtRecord[], sort: TechDebtSortOptions): TechDebtRecord[];
+    private computeQuerySummary;
+}
+//# sourceMappingURL=TechDebtService.d.ts.map