opencode-conductor-cdd-plugin 1.0.0-beta.16 → 1.0.0-beta.18

package/dist/utils/metadataTracker.js

@@ -0,0 +1,105 @@
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+export class MetadataTracker {
+    workDir;
+    trackId;
+    metadataPath;
+    constructor(workDir, trackId) {
+        this.workDir = workDir;
+        this.trackId = trackId;
+        this.metadataPath = join(workDir, "conductor-cdd", "tracks", trackId, "status.json");
+    }
+    ensureDirectory() {
+        const dir = join(this.metadataPath, "..");
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    initializeMetadata(metadata) {
+        this.ensureDirectory();
+        writeFileSync(this.metadataPath, JSON.stringify(metadata, null, 2));
+    }
+    readMetadata() {
+        if (!existsSync(this.metadataPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(readFileSync(this.metadataPath, "utf-8"));
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    writeMetadata(metadata) {
+        metadata.updatedAt = new Date().toISOString();
+        writeFileSync(this.metadataPath, JSON.stringify(metadata, null, 2));
+    }
+    updateTaskStatus(phaseId, taskId, status, commitSha) {
+        const metadata = this.readMetadata();
+        if (!metadata) {
+            throw new Error("Metadata file does not exist. Initialize first.");
+        }
+        const phase = metadata.phases.find(p => p.phaseId === phaseId);
+        if (!phase) {
+            throw new Error(`Phase '${phaseId}' not found`);
+        }
+        const task = phase.tasks.find(t => t.taskId === taskId);
+        if (!task) {
+            throw new Error(`Task '${taskId}' not found in phase '${phaseId}'`);
+        }
+        task.status = status;
+        if (commitSha) {
+            task.commitSha = commitSha;
+        }
+        if (status === "in_progress" && !task.startedAt) {
+            task.startedAt = new Date().toISOString();
+        }
+        if (status === "completed") {
+            task.completedAt = new Date().toISOString();
+        }
+        this.writeMetadata(metadata);
+    }
+    updatePhaseStatus(phaseId, status, checkpointSha) {
+        const metadata = this.readMetadata();
+        if (!metadata) {
+            throw new Error("Metadata file does not exist. Initialize first.");
+        }
+        const phase = metadata.phases.find(p => p.phaseId === phaseId);
+        if (!phase) {
+            throw new Error(`Phase '${phaseId}' not found`);
+        }
+        phase.status = status;
+        if (checkpointSha) {
+            phase.checkpointSha = checkpointSha;
+        }
+        this.writeMetadata(metadata);
+    }
+    getActivePhase() {
+        const metadata = this.readMetadata();
+        if (!metadata) {
+            return null;
+        }
+        // First look for in_progress phase
+        const inProgressPhase = metadata.phases.find(p => p.status === "in_progress");
+        if (inProgressPhase) {
+            return inProgressPhase;
+        }
+        // Then look for first pending phase
+        const pendingPhase = metadata.phases.find(p => p.status === "pending");
+        return pendingPhase || null;
+    }
+    getActiveTask() {
+        const activePhase = this.getActivePhase();
+        if (!activePhase) {
+            return null;
+        }
+        // First look for in_progress task
+        const inProgressTask = activePhase.tasks.find(t => t.status === "in_progress");
+        if (inProgressTask) {
+            return inProgressTask;
+        }
+        // Then look for first pending task
+        const pendingTask = activePhase.tasks.find(t => t.status === "pending");
+        return pendingTask || null;
+    }
+}

package/dist/utils/metadataTracker.test.d.ts

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

package/dist/utils/metadataTracker.test.js

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { MetadataTracker } from "./metadataTracker.js";
+describe("MetadataTracker", () => {
+    const testDir = join(process.cwd(), "test-metadata-tracker");
+    const trackId = "track_test_123";
+    let tracker;
+    beforeEach(() => {
+        // Create test directory
+        mkdirSync(testDir, { recursive: true });
+        tracker = new MetadataTracker(testDir, trackId);
+    });
+    afterEach(() => {
+        // Clean up
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    describe("initializeMetadata", () => {
+        it("should create a status.json file with initial metadata", () => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "pending",
+                        tasks: [
+                            {
+                                taskId: "task1",
+                                taskName: "Task 1",
+                                status: "pending"
+                            }
+                        ]
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+            const metadataPath = join(testDir, "conductor-cdd", "tracks", trackId, "status.json");
+            expect(existsSync(metadataPath)).toBe(true);
+            const savedMetadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+            expect(savedMetadata.trackId).toBe(trackId);
+            expect(savedMetadata.trackName).toBe("Test Track");
+            expect(savedMetadata.phases).toHaveLength(1);
+        });
+    });
+    describe("updateTaskStatus", () => {
+        beforeEach(() => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "pending",
+                        tasks: [
+                            {
+                                taskId: "task1",
+                                taskName: "Task 1",
+                                status: "pending"
+                            },
+                            {
+                                taskId: "task2",
+                                taskName: "Task 2",
+                                status: "pending"
+                            }
+                        ]
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+        });
+        it("should update a task status from pending to in_progress", () => {
+            tracker.updateTaskStatus("phase1", "task1", "in_progress");
+            const metadata = tracker.readMetadata();
+            expect(metadata).not.toBeNull();
+            const task = metadata.phases[0].tasks.find((t) => t.taskId === "task1");
+            expect(task?.status).toBe("in_progress");
+        });
+        it("should update a task status from in_progress to completed with commit SHA", () => {
+            tracker.updateTaskStatus("phase1", "task1", "in_progress");
+            tracker.updateTaskStatus("phase1", "task1", "completed", "abc1234");
+            const metadata = tracker.readMetadata();
+            expect(metadata).not.toBeNull();
+            const task = metadata.phases[0].tasks.find((t) => t.taskId === "task1");
+            expect(task?.status).toBe("completed");
+            expect(task?.commitSha).toBe("abc1234");
+        });
+        it("should update the updatedAt timestamp", async () => {
+            // Wait a small amount to ensure timestamp changes
+            const beforeUpdate = tracker.readMetadata().updatedAt;
+            await new Promise(resolve => setTimeout(resolve, 10));
+            tracker.updateTaskStatus("phase1", "task1", "in_progress");
+            const afterUpdate = tracker.readMetadata().updatedAt;
+            expect(afterUpdate).not.toBe(beforeUpdate);
+        });
+        it("should throw error if phase does not exist", () => {
+            expect(() => {
+                tracker.updateTaskStatus("invalid_phase", "task1", "in_progress");
+            }).toThrow("Phase 'invalid_phase' not found");
+        });
+        it("should throw error if task does not exist", () => {
+            expect(() => {
+                tracker.updateTaskStatus("phase1", "invalid_task", "in_progress");
+            }).toThrow("Task 'invalid_task' not found in phase 'phase1'");
+        });
+    });
+    describe("updatePhaseStatus", () => {
+        beforeEach(() => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "pending",
+                        tasks: []
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+        });
+        it("should update a phase status to completed with checkpoint SHA", () => {
+            tracker.updatePhaseStatus("phase1", "completed", "def5678");
+            const metadata = tracker.readMetadata();
+            expect(metadata).not.toBeNull();
+            const phase = metadata.phases.find((p) => p.phaseId === "phase1");
+            expect(phase?.status).toBe("completed");
+            expect(phase?.checkpointSha).toBe("def5678");
+        });
+        it("should throw error if phase does not exist", () => {
+            expect(() => {
+                tracker.updatePhaseStatus("invalid_phase", "completed");
+            }).toThrow("Phase 'invalid_phase' not found");
+        });
+    });
+    describe("readMetadata", () => {
+        it("should return null if status.json does not exist", () => {
+            const metadata = tracker.readMetadata();
+            expect(metadata).toBeNull();
+        });
+        it("should return parsed metadata if status.json exists", () => {
+            const initialMetadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(initialMetadata);
+            const metadata = tracker.readMetadata();
+            expect(metadata).not.toBeNull();
+            expect(metadata?.trackId).toBe(trackId);
+        });
+    });
+    describe("getActivePhase", () => {
+        beforeEach(() => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "completed",
+                        tasks: []
+                    },
+                    {
+                        phaseId: "phase2",
+                        phaseName: "Phase 2: Implementation",
+                        status: "in_progress",
+                        tasks: []
+                    },
+                    {
+                        phaseId: "phase3",
+                        phaseName: "Phase 3: Testing",
+                        status: "pending",
+                        tasks: []
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+        });
+        it("should return the first in_progress phase", () => {
+            const activePhase = tracker.getActivePhase();
+            expect(activePhase?.phaseId).toBe("phase2");
+        });
+        it("should return the first pending phase if no in_progress phase exists", () => {
+            tracker.updatePhaseStatus("phase2", "completed");
+            const activePhase = tracker.getActivePhase();
+            expect(activePhase?.phaseId).toBe("phase3");
+        });
+        it("should return null if all phases are completed", () => {
+            tracker.updatePhaseStatus("phase2", "completed");
+            tracker.updatePhaseStatus("phase3", "completed");
+            const activePhase = tracker.getActivePhase();
+            expect(activePhase).toBeNull();
+        });
+    });
+    describe("getActiveTask", () => {
+        beforeEach(() => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "in_progress",
+                        tasks: [
+                            {
+                                taskId: "task1",
+                                taskName: "Task 1",
+                                status: "completed"
+                            },
+                            {
+                                taskId: "task2",
+                                taskName: "Task 2",
+                                status: "in_progress"
+                            },
+                            {
+                                taskId: "task3",
+                                taskName: "Task 3",
+                                status: "pending"
+                            }
+                        ]
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+        });
+        it("should return the first in_progress task in the active phase", () => {
+            const activeTask = tracker.getActiveTask();
+            expect(activeTask?.taskId).toBe("task2");
+        });
+        it("should return the first pending task if no in_progress task exists", () => {
+            tracker.updateTaskStatus("phase1", "task2", "completed");
+            const activeTask = tracker.getActiveTask();
+            expect(activeTask?.taskId).toBe("task3");
+        });
+        it("should return null if all tasks in active phase are completed", () => {
+            tracker.updateTaskStatus("phase1", "task2", "completed");
+            tracker.updateTaskStatus("phase1", "task3", "completed");
+            const activeTask = tracker.getActiveTask();
+            expect(activeTask).toBeNull();
+        });
+        it("should return null if there is no active phase", () => {
+            tracker.updatePhaseStatus("phase1", "completed");
+            const activeTask = tracker.getActiveTask();
+            expect(activeTask).toBeNull();
+        });
+    });
+});

package/dist/utils/planParser.d.ts

@@ -0,0 +1,25 @@
+export interface PlanPhase {
+    phaseId: string;
+    phaseName: string;
+    content: string;
+}
+/**
+ * Adds machine-parsable XML-style delimiters around each phase in a plan.md file
+ * @param planContent The original plan.md content
+ * @returns The plan content with phase delimiters added
+ */
+export declare function addPhaseDelimiters(planContent: string): string;
+/**
+ * Extracts the active phase from a delimited plan
+ * Active phase is the first in-progress phase, or first pending phase if none in progress
+ * @param delimitedPlan Plan content with phase delimiters
+ * @returns The active phase or null if all phases complete
+ */
+export declare function extractActivePhase(delimitedPlan: string): PlanPhase | null;
+/**
+ * Extracts a specific phase by name (case-insensitive partial match)
+ * @param delimitedPlan Plan content with phase delimiters
+ * @param phaseName Name or partial name of the phase
+ * @returns The matching phase or null
+ */
+export declare function extractPhaseByName(delimitedPlan: string, phaseName: string): PlanPhase | null;

package/dist/utils/planParser.js

@@ -0,0 +1,107 @@
+/**
+ * Adds machine-parsable XML-style delimiters around each phase in a plan.md file
+ * @param planContent The original plan.md content
+ * @returns The plan content with phase delimiters added
+ */
+export function addPhaseDelimiters(planContent) {
+    const lines = planContent.split("\n");
+    const result = [];
+    let phaseCounter = 0;
+    let inPhase = false;
+    let currentPhaseId = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Detect phase header (## Phase X: ...)
+        const phaseMatch = line.match(/^##\s+Phase\s+\d+:/i);
+        if (phaseMatch) {
+            // Close previous phase if exists
+            if (inPhase) {
+                result.push(`<!-- PHASE_END:${currentPhaseId} -->`);
+            }
+            // Start new phase
+            phaseCounter++;
+            currentPhaseId = `phase${phaseCounter}`;
+            result.push(`<!-- PHASE_START:${currentPhaseId} -->`);
+            result.push(line);
+            inPhase = true;
+        }
+        else {
+            result.push(line);
+            // Close phase if we hit the next phase or end of file
+            if (inPhase && i === lines.length - 1) {
+                result.push(`<!-- PHASE_END:${currentPhaseId} -->`);
+            }
+        }
+        // Check if next line is a new phase header to close current phase
+        if (inPhase && i + 1 < lines.length) {
+            const nextLine = lines[i + 1];
+            const nextPhaseMatch = nextLine.match(/^##\s+Phase\s+\d+:/i);
+            if (nextPhaseMatch) {
+                result.push(`<!-- PHASE_END:${currentPhaseId} -->`);
+                inPhase = false;
+            }
+        }
+    }
+    return result.join("\n");
+}
+/**
+ * Extracts the active phase from a delimited plan
+ * Active phase is the first in-progress phase, or first pending phase if none in progress
+ * @param delimitedPlan Plan content with phase delimiters
+ * @returns The active phase or null if all phases complete
+ */
+export function extractActivePhase(delimitedPlan) {
+    const phases = extractAllPhases(delimitedPlan);
+    if (phases.length === 0) {
+        return null;
+    }
+    // Find first in-progress phase (contains [~])
+    const inProgressPhase = phases.find(p => p.content.includes("[~]"));
+    if (inProgressPhase) {
+        return inProgressPhase;
+    }
+    // Find first pending phase (contains [ ] but no checkpoint marker)
+    const pendingPhase = phases.find(p => {
+        const hasIncompleteTasks = p.content.includes("[ ]");
+        const hasCheckpoint = p.content.includes("[checkpoint:");
+        return hasIncompleteTasks || !hasCheckpoint;
+    });
+    return pendingPhase || null;
+}
+/**
+ * Extracts a specific phase by name (case-insensitive partial match)
+ * @param delimitedPlan Plan content with phase delimiters
+ * @param phaseName Name or partial name of the phase
+ * @returns The matching phase or null
+ */
+export function extractPhaseByName(delimitedPlan, phaseName) {
+    const phases = extractAllPhases(delimitedPlan);
+    const normalizedName = phaseName.toLowerCase();
+    return (phases.find(p => p.phaseName.toLowerCase().includes(normalizedName)) || null);
+}
+/**
+ * Extracts all phases from a delimited plan
+ * @param delimitedPlan Plan content with phase delimiters
+ * @returns Array of all phases
+ */
+function extractAllPhases(delimitedPlan) {
+    const phases = [];
+    const phaseRegex = /<!-- PHASE_START:(\w+) -->[\s\S]*?<!-- PHASE_END:\1 -->/g;
+    const matches = delimitedPlan.matchAll(phaseRegex);
+    for (const match of matches) {
+        const phaseId = match[1];
+        const content = match[0];
+        // Extract phase name from the content
+        const nameMatch = content.match(/^<!-- PHASE_START:\w+ -->\s*\n##\s+(.+)$/m);
+        const phaseName = nameMatch ? nameMatch[1].trim() : phaseId;
+        phases.push({
+            phaseId,
+            phaseName,
+            content: content
+                .replace(/<!-- PHASE_START:\w+ -->\n?/, "")
+                .replace(/\n?<!-- PHASE_END:\w+ -->/, "")
+                .trim()
+        });
+    }
+    return phases;
+}

package/dist/utils/planParser.test.d.ts

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

package/dist/utils/planParser.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { addPhaseDelimiters, extractActivePhase, extractPhaseByName } from "./planParser.js";
+describe("planParser", () => {
+    const samplePlan = `# Implementation Plan: Sample Track
+
+This is the introduction.
+
+## Phase 1: Setup
+*Goal: Set up the project infrastructure.*
+
+- [x] Task: Initialize repository (abc1234)
+- [x] Task: Configure tools (def5678)
+- [x] Task: Orchestrator - User Manual Verification 'Phase 1: Setup' [checkpoint: aaa1111]
+
+## Phase 2: Implementation
+*Goal: Implement core features.*
+
+- [~] Task: Design API
+- [ ] Task: Implement endpoints
+- [ ] Task: Orchestrator - User Manual Verification 'Phase 2: Implementation'
+
+## Phase 3: Testing
+*Goal: Write and run tests.*
+
+- [ ] Task: Unit tests
+- [ ] Task: Integration tests
+- [ ] Task: Orchestrator - User Manual Verification 'Phase 3: Testing'
+`;
+    describe("addPhaseDelimiters", () => {
+        it("should add XML-style phase delimiters to plan.md content", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            expect(delimited).toContain("<!-- PHASE_START:phase1 -->");
+            expect(delimited).toContain("<!-- PHASE_END:phase1 -->");
+            expect(delimited).toContain("<!-- PHASE_START:phase2 -->");
+            expect(delimited).toContain("<!-- PHASE_END:phase2 -->");
+            expect(delimited).toContain("<!-- PHASE_START:phase3 -->");
+            expect(delimited).toContain("<!-- PHASE_END:phase3 -->");
+        });
+        it("should preserve all original content", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            expect(delimited).toContain("# Implementation Plan: Sample Track");
+            expect(delimited).toContain("## Phase 1: Setup");
+            expect(delimited).toContain("- [x] Task: Initialize repository");
+            expect(delimited).toContain("## Phase 2: Implementation");
+            expect(delimited).toContain("## Phase 3: Testing");
+        });
+        it("should handle plan with no phases", () => {
+            const noPhasePlan = "# Plan\n\nJust some intro text.";
+            const delimited = addPhaseDelimiters(noPhasePlan);
+            expect(delimited).toBe(noPhasePlan);
+        });
+    });
+    describe("extractActivePhase", () => {
+        it("should extract the first in-progress phase", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            const activePhase = extractActivePhase(delimited);
+            expect(activePhase).not.toBeNull();
+            expect(activePhase?.phaseId).toBe("phase2");
+            expect(activePhase?.content).toContain("## Phase 2: Implementation");
+            expect(activePhase?.content).toContain("- [~] Task: Design API");
+        });
+        it("should extract the first pending phase if no in-progress phase", () => {
+            const allCompletedPlan = `# Plan
+
+<!-- PHASE_START:phase1 -->
+## Phase 1: Setup
+- [x] Task: Done [checkpoint: xxx]
+<!-- PHASE_END:phase1 -->
+
+<!-- PHASE_START:phase2 -->
+## Phase 2: Testing
+- [ ] Task: Todo
+<!-- PHASE_END:phase2 -->`;
+            const activePhase = extractActivePhase(allCompletedPlan);
+            expect(activePhase).not.toBeNull();
+            expect(activePhase?.phaseId).toBe("phase2");
+        });
+        it("should return null if all phases are completed", () => {
+            const allCompletedPlan = `# Plan
+
+<!-- PHASE_START:phase1 -->
+## Phase 1: Setup
+- [x] Task: Done [checkpoint: xxx]
+<!-- PHASE_END:phase1 -->
+
+<!-- PHASE_START:phase2 -->
+## Phase 2: Testing
+- [x] Task: Done [checkpoint: yyy]
+<!-- PHASE_END:phase2 -->`;
+            const activePhase = extractActivePhase(allCompletedPlan);
+            expect(activePhase).toBeNull();
+        });
+        it("should return null if no delimiters found", () => {
+            const activePhase = extractActivePhase(samplePlan);
+            expect(activePhase).toBeNull();
+        });
+    });
+    describe("extractPhaseByName", () => {
+        it("should extract a specific phase by name", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            const phase = extractPhaseByName(delimited, "Phase 1: Setup");
+            expect(phase).not.toBeNull();
+            expect(phase?.phaseId).toBe("phase1");
+            expect(phase?.content).toContain("## Phase 1: Setup");
+            expect(phase?.content).toContain("- [x] Task: Initialize repository");
+        });
+        it("should return null if phase name not found", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            const phase = extractPhaseByName(delimited, "Phase 99: Nonexistent");
+            expect(phase).toBeNull();
+        });
+        it("should handle partial name matches", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            const phase = extractPhaseByName(delimited, "Implementation");
+            expect(phase).not.toBeNull();
+            expect(phase?.phaseId).toBe("phase2");
+        });
+    });
+});

package/dist/utils/statusDisplay.d.ts

@@ -0,0 +1,35 @@
+export interface TrackStatusInfo {
+    trackId: string;
+    trackName: string;
+    totalTasks: number;
+    completedTasks: number;
+    inProgressTasks: number;
+    currentPhase: string;
+    lastUpdated: string;
+}
+export interface StatusFormatOptions {
+    compact?: boolean;
+    noColor?: boolean;
+    barLength?: number;
+}
+/**
+ * Calculates progress percentage
+ * @param completed Number of completed items
+ * @param total Total number of items
+ * @returns Progress percentage (0-100)
+ */
+export declare function calculateProgress(completed: number, total: number): number;
+/**
+ * Generates a visual progress bar
+ * @param percentage Progress percentage (0-100)
+ * @param length Length of the progress bar (default: 20)
+ * @returns Progress bar string
+ */
+export declare function generateProgressBar(percentage: number, length?: number): string;
+/**
+ * Formats track status into a visually appealing display
+ * @param track Track status information
+ * @param options Formatting options
+ * @returns Formatted status string
+ */
+export declare function formatTrackStatus(track: TrackStatusInfo, options?: StatusFormatOptions): string;