@mcoda/core 0.1.4

package/dist/services/jobs/JobService.js

@@ -0,0 +1,490 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { PathHelper } from "@mcoda/shared";
+import { WorkspaceRepository, } from "@mcoda/db";
+const nowIso = () => new Date().toISOString();
+export class JobService {
+    constructor(workspace, workspaceRepo, options = {}) {
+        this.workspaceRepo = workspaceRepo;
+        this.checkpointCounters = new Map();
+        this.workspaceRepoInit = false;
+        this.telemetryWarningShown = false;
+        this.telemetryRemoteWarningShown = false;
+        const resolvedRoot = typeof workspace === "string" ? workspace : workspace.workspaceRoot;
+        this.workspaceRoot = resolvedRoot;
+        this.workspaceId = typeof workspace === "string" ? resolvedRoot : workspace.workspaceId ?? resolvedRoot;
+        this.perRunTelemetryDisabled = options.noTelemetry ?? false;
+        this.envTelemetryDisabled = (process.env.MCODA_TELEMETRY ?? "").toLowerCase() === "off";
+        this.requireRepo = options.requireRepo ?? false;
+    }
+    get mcodaDir() {
+        return path.join(this.workspaceRoot, ".mcoda");
+    }
+    get commandRunsPath() {
+        return path.join(this.mcodaDir, "command_runs.json");
+    }
+    get jobsStorePath() {
+        return path.join(this.mcodaDir, "jobs.json");
+    }
+    get tokenUsagePath() {
+        return path.join(this.mcodaDir, "token_usage.json");
+    }
+    jobDir(jobId) {
+        return path.join(this.mcodaDir, "jobs", jobId);
+    }
+    manifestPath(jobId) {
+        return path.join(this.jobDir(jobId), "manifest.json");
+    }
+    checkpointDir(jobId) {
+        return path.join(this.jobDir(jobId), "checkpoints");
+    }
+    logsDir(jobId) {
+        return path.join(this.jobDir(jobId), "logs");
+    }
+    async ensureMcoda() {
+        await PathHelper.ensureDir(this.mcodaDir);
+        if (this.workspaceRepoInit)
+            return;
+        this.workspaceRepoInit = true;
+        if (process.env.MCODA_DISABLE_DB === "1") {
+            if (this.requireRepo) {
+                throw new Error("Workspace DB disabled via MCODA_DISABLE_DB; job operations require the workspace DB per SDS.");
+            }
+            this.workspaceRepo = undefined;
+            return;
+        }
+        try {
+            if (!this.workspaceRepo) {
+                this.workspaceRepo = await WorkspaceRepository.create(this.workspaceRoot);
+            }
+        }
+        catch (error) {
+            if (this.requireRepo) {
+                throw new Error(`Workspace DB could not be opened for jobs (${error.message}); run mcoda init/create-tasks to initialize the workspace.`);
+            }
+            // Fall back to JSON stores if sqlite is unavailable or schema mismatches.
+            this.workspaceRepo = undefined;
+        }
+    }
+    async readJsonArray(filePath) {
+        try {
+            const raw = await fs.readFile(filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed))
+                return parsed;
+            return [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async writeJsonArray(filePath, records) {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, JSON.stringify(records, null, 2), "utf8");
+    }
+    async appendJsonArray(filePath, record) {
+        const existing = await this.readJsonArray(filePath);
+        existing.push(record);
+        await this.writeJsonArray(filePath, existing);
+    }
+    async listJobs() {
+        await this.ensureMcoda();
+        if (this.workspaceRepo && "listJobs" in this.workspaceRepo) {
+            const rows = await this.workspaceRepo.listJobs();
+            return rows;
+        }
+        return this.readJsonArray(this.jobsStorePath);
+    }
+    async getJob(jobId) {
+        await this.ensureMcoda();
+        if (this.workspaceRepo && "getJob" in this.workspaceRepo) {
+            return (await this.workspaceRepo.getJob(jobId)) ?? undefined;
+        }
+        const jobs = await this.readJsonArray(this.jobsStorePath);
+        return jobs.find((j) => j.id === jobId);
+    }
+    async readCheckpoints(jobId) {
+        const dir = this.checkpointDir(jobId);
+        try {
+            const entries = await fs.readdir(dir);
+            const checkpoints = [];
+            for (const entry of entries.sort()) {
+                const raw = await fs.readFile(path.join(dir, entry), "utf8");
+                checkpoints.push(JSON.parse(raw));
+            }
+            return checkpoints;
+        }
+        catch {
+            return [];
+        }
+    }
+    async readLog(jobId) {
+        const logPath = path.join(this.logsDir(jobId), "stream.log");
+        try {
+            return await fs.readFile(logPath, "utf8");
+        }
+        catch {
+            return "";
+        }
+    }
+    async listJobLogs(jobId, options = {}) {
+        await this.ensureMcoda();
+        if (this.workspaceRepo && "getDb" in this.workspaceRepo) {
+            const db = this.workspaceRepo.getDb();
+            const clauses = ["tr.job_id = ?"];
+            const params = [jobId];
+            if (options.since) {
+                clauses.push("datetime(tl.timestamp) >= datetime(?)");
+                params.push(options.since);
+            }
+            if (options.after?.timestamp) {
+                clauses.push("(datetime(tl.timestamp) > datetime(?) OR (tl.timestamp = ? AND COALESCE(tl.sequence,0) > COALESCE(?,0)))");
+                params.push(options.after.timestamp, options.after.timestamp, options.after.sequence ?? 0);
+            }
+            const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+            const rows = (await db.all(`
+        SELECT tl.timestamp, tl.sequence, tl.level, tl.source, tl.message, tl.details_json, tr.task_id, tr.command, t.key as task_key
+        FROM task_logs tl
+        JOIN task_runs tr ON tr.id = tl.task_run_id
+        LEFT JOIN tasks t ON t.id = tr.task_id
+        ${where}
+        ORDER BY datetime(tl.timestamp) ASC, tl.sequence ASC
+        LIMIT 500
+        `, ...params));
+            return rows.map((row) => {
+                const details = row.details_json ? JSON.parse(row.details_json) : null;
+                return {
+                    timestamp: row.timestamp,
+                    sequence: row.sequence ?? null,
+                    level: row.level ?? null,
+                    source: row.source ?? null,
+                    message: row.message ?? null,
+                    taskId: row.task_id ?? null,
+                    taskKey: row.task_key ?? null,
+                    phase: details?.phase ?? row.command ?? null,
+                    details,
+                };
+            });
+        }
+        // Fallback to file-based stream log when DB access is not available.
+        const raw = await this.readLog(jobId);
+        const lines = raw.split(/\r?\n/).filter(Boolean);
+        return lines.map((line, idx) => ({
+            timestamp: nowIso(),
+            sequence: idx,
+            message: line,
+        }));
+    }
+    async summarizeTaskRuns(jobId) {
+        await this.ensureMcoda();
+        if (this.workspaceRepo && "getDb" in this.workspaceRepo) {
+            const db = this.workspaceRepo.getDb();
+            const rows = (await db.all(`
+        SELECT tr.task_id, tr.status, tr.started_at, tr.finished_at, tr.command, t.key as task_key
+        FROM task_runs tr
+        LEFT JOIN tasks t ON t.id = tr.task_id
+        WHERE tr.job_id = ?
+        ORDER BY datetime(tr.started_at) ASC, datetime(tr.finished_at) ASC
+        `, jobId));
+            return rows.map((row) => ({
+                taskId: row.task_id ?? null,
+                taskKey: row.task_key ?? null,
+                status: row.status ?? null,
+                startedAt: row.started_at ?? null,
+                finishedAt: row.finished_at ?? null,
+                command: row.command ?? null,
+            }));
+        }
+        return [];
+    }
+    async startCommandRun(commandName, projectKey, options) {
+        await this.ensureMcoda();
+        const startedAt = nowIso();
+        let record = {
+            id: randomUUID(),
+            commandName,
+            workspaceId: this.workspaceId,
+            projectKey,
+            jobId: options?.jobId,
+            taskIds: options?.taskIds,
+            gitBranch: options?.gitBranch,
+            gitBaseBranch: options?.gitBaseBranch,
+            startedAt,
+            status: "running",
+            spProcessed: null,
+        };
+        if (this.workspaceRepo) {
+            const row = await this.workspaceRepo.createCommandRun({
+                workspaceId: this.workspaceId,
+                commandName,
+                jobId: record.jobId,
+                taskIds: record.taskIds,
+                gitBranch: record.gitBranch,
+                gitBaseBranch: record.gitBaseBranch,
+                startedAt,
+                status: "running",
+            });
+            record = { ...record, id: row.id };
+        }
+        await this.appendJsonArray(this.commandRunsPath, record);
+        return record;
+    }
+    async finishCommandRun(runId, status, errorSummary, spProcessed) {
+        const runs = await this.readJsonArray(this.commandRunsPath);
+        const idx = runs.findIndex((r) => r.id === runId);
+        if (idx === -1)
+            return;
+        const completedAt = nowIso();
+        const durationSeconds = runs[idx].startedAt ? (Date.parse(completedAt) - Date.parse(runs[idx].startedAt)) / 1000 : undefined;
+        runs[idx] = { ...runs[idx], completedAt, status, errorSummary, durationSeconds, spProcessed: spProcessed ?? runs[idx].spProcessed };
+        await this.writeJsonArray(this.commandRunsPath, runs);
+        if (this.workspaceRepo) {
+            await this.workspaceRepo.completeCommandRun(runId, {
+                status,
+                completedAt,
+                errorSummary,
+                durationSeconds,
+                spProcessed: spProcessed ?? runs[idx].spProcessed ?? null,
+            });
+        }
+    }
+    async startJob(type, commandRunId, projectKey, options = {}) {
+        await this.ensureMcoda();
+        const createdAt = nowIso();
+        let record = {
+            id: randomUUID(),
+            type,
+            state: "running",
+            commandRunId,
+            commandName: options.commandName ?? type,
+            workspaceId: this.workspaceId,
+            projectKey,
+            payload: options.payload,
+            totalItems: options.totalItems,
+            processedItems: options.processedItems,
+            totalUnits: options.totalItems,
+            completedUnits: options.processedItems,
+            createdAt,
+            updatedAt: createdAt,
+        };
+        if (this.workspaceRepo) {
+            const row = await this.workspaceRepo.createJob({
+                workspaceId: this.workspaceId,
+                type,
+                state: "running",
+                commandName: record.commandName,
+                payload: options.payload,
+                totalItems: record.totalItems,
+                processedItems: record.processedItems,
+            });
+            record = { ...record, id: row.id, createdAt: row.createdAt, updatedAt: row.updatedAt };
+        }
+        const jobs = await this.readJsonArray(this.jobsStorePath);
+        jobs.push(record);
+        await this.writeJsonArray(this.jobsStorePath, jobs);
+        await this.writeManifest(record);
+        if (commandRunId) {
+            await this.attachCommandRunToJob(commandRunId, record.id);
+        }
+        return record;
+    }
+    async attachCommandRunToJob(commandRunId, jobId) {
+        const runs = await this.readJsonArray(this.commandRunsPath);
+        const idx = runs.findIndex((r) => r.id === commandRunId);
+        if (idx !== -1) {
+            runs[idx] = { ...runs[idx], jobId };
+            await this.writeJsonArray(this.commandRunsPath, runs);
+        }
+        if (this.workspaceRepo && "setCommandRunJobId" in this.workspaceRepo) {
+            try {
+                await this.workspaceRepo.setCommandRunJobId(commandRunId, jobId);
+            }
+            catch {
+                // ignore linking failures
+            }
+        }
+    }
+    async updateJobStatus(jobId, state, metadata) {
+        const jobs = await this.readJsonArray(this.jobsStorePath);
+        const idx = jobs.findIndex((j) => j.id === jobId);
+        if (idx === -1)
+            return;
+        const completedAt = state !== "running" && state !== "queued" ? nowIso() : jobs[idx].completedAt;
+        const durationSeconds = completedAt && jobs[idx].createdAt ? (Date.parse(completedAt) - Date.parse(jobs[idx].createdAt)) / 1000 : jobs[idx].durationSeconds;
+        const jobStateDetail = metadata?.job_state_detail ?? metadata?.jobStateDetail ?? jobs[idx].jobStateDetail;
+        const payloadUpdate = metadata?.payload ??
+            (metadata
+                ? Object.fromEntries(Object.entries(metadata).filter(([key]) => !["payload", "totalItems", "processedItems", "lastCheckpoint", "errorSummary", "error"].includes(key)))
+                : undefined);
+        const updated = {
+            ...jobs[idx],
+            state,
+            jobState: state,
+            jobStateDetail,
+            payload: payloadUpdate ? { ...(jobs[idx].payload ?? {}), ...payloadUpdate } : jobs[idx].payload,
+            totalItems: metadata?.totalItems ?? jobs[idx].totalItems,
+            processedItems: metadata?.processedItems ?? jobs[idx].processedItems,
+            totalUnits: metadata?.totalUnits ?? metadata?.totalItems ?? jobs[idx].totalUnits ?? jobs[idx].totalItems,
+            completedUnits: metadata?.completedUnits ?? metadata?.processedItems ?? jobs[idx].completedUnits ?? jobs[idx].processedItems,
+            lastCheckpoint: metadata?.lastCheckpoint ?? jobs[idx].lastCheckpoint,
+            errorSummary: metadata?.errorSummary ?? metadata?.error ?? jobs[idx].errorSummary,
+            updatedAt: nowIso(),
+            completedAt,
+            durationSeconds,
+        };
+        jobs[idx] = updated;
+        await this.writeJsonArray(this.jobsStorePath, jobs);
+        await this.writeManifest(updated);
+        if (this.workspaceRepo) {
+            await this.workspaceRepo.updateJobState(jobId, {
+                state,
+                commandName: updated.commandName ?? updated.type,
+                totalItems: updated.totalItems,
+                processedItems: updated.processedItems,
+                lastCheckpoint: updated.lastCheckpoint,
+                errorSummary: updated.errorSummary,
+                completedAt: updated.completedAt ?? null,
+                payload: updated.payload,
+            });
+        }
+    }
+    async writeCheckpoint(jobId, checkpoint) {
+        const dir = this.checkpointDir(jobId);
+        await PathHelper.ensureDir(dir);
+        let current = this.checkpointCounters.get(jobId);
+        if (current === undefined) {
+            try {
+                const entries = await fs.readdir(dir);
+                const nums = entries
+                    .map((e) => Number.parseInt(e.replace(/\.ckpt\.json$/, ""), 10))
+                    .filter((n) => Number.isFinite(n));
+                current = nums.length ? Math.max(...nums) : 0;
+            }
+            catch {
+                current = 0;
+            }
+        }
+        const next = (current ?? 0) + 1;
+        this.checkpointCounters.set(jobId, next);
+        const filename = `${String(next).padStart(6, "0")}.ckpt.json`;
+        const target = path.join(dir, filename);
+        const job = await this.getJob(jobId);
+        const createdAt = nowIso();
+        const payload = {
+            schema_version: 1,
+            job_id: jobId,
+            checkpoint_seq: next,
+            checkpoint_id: randomUUID(),
+            created_at: createdAt,
+            status: job?.state ?? "running",
+            stage: checkpoint.stage,
+            timestamp: checkpoint.timestamp ?? createdAt,
+            reason: checkpoint.details?.reason,
+            progress: {
+                total: job?.totalItems ?? checkpoint.details?.totalItems ?? null,
+                completed: job?.processedItems ?? checkpoint.details?.processedItems ?? null,
+            },
+            details: checkpoint.details,
+        };
+        await fs.writeFile(target, JSON.stringify(payload, null, 2), "utf8");
+        if (this.workspaceRepo) {
+            await this.workspaceRepo.updateJobState(jobId, {
+                lastCheckpoint: checkpoint.stage,
+            });
+        }
+    }
+    async appendLog(jobId, content) {
+        const logDir = this.logsDir(jobId);
+        await PathHelper.ensureDir(logDir);
+        const logPath = path.join(logDir, "stream.log");
+        await fs.appendFile(logPath, content, "utf8");
+    }
+    async readTelemetryConfig() {
+        const configPath = path.join(this.mcodaDir, "config.json");
+        try {
+            const raw = await fs.readFile(configPath, "utf8");
+            const parsed = JSON.parse(raw);
+            return parsed.telemetry;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async shouldRecordTokenUsage() {
+        if (this.telemetryConfig === undefined) {
+            this.telemetryConfig = await this.readTelemetryConfig();
+        }
+        if (this.telemetryConfig?.strict) {
+            if (!this.telemetryWarningShown) {
+                // eslint-disable-next-line no-console
+                console.warn("Telemetry strict mode is enabled; token usage will not be recorded locally.");
+                this.telemetryWarningShown = true;
+            }
+            return false;
+        }
+        if ((this.perRunTelemetryDisabled || this.envTelemetryDisabled || this.telemetryConfig?.optOut) &&
+            !this.telemetryRemoteWarningShown) {
+            // eslint-disable-next-line no-console
+            console.warn("Remote telemetry export disabled for this run (--no-telemetry/MCODA_TELEMETRY=off or opt-out). Local logging still enabled unless telemetry.strict is set.");
+            this.telemetryRemoteWarningShown = true;
+        }
+        return true;
+    }
+    async recordTokenUsage(entry) {
+        const recordTelemetry = await this.shouldRecordTokenUsage();
+        if (!recordTelemetry)
+            return;
+        const normalized = {
+            workspaceId: entry.workspaceId ?? this.workspaceId,
+            agentId: entry.agentId ?? null,
+            modelName: entry.modelName ?? null,
+            jobId: entry.jobId ?? null,
+            commandRunId: entry.commandRunId ?? null,
+            taskRunId: entry.taskRunId ?? null,
+            taskId: entry.taskId ?? null,
+            projectId: entry.projectId ?? null,
+            epicId: entry.epicId ?? null,
+            userStoryId: entry.userStoryId ?? null,
+            tokensPrompt: entry.tokensPrompt ?? entry.promptTokens ?? null,
+            tokensCompletion: entry.tokensCompletion ?? entry.completionTokens ?? null,
+            tokensTotal: entry.tokensTotal ?? null,
+            costEstimate: entry.costEstimate ?? entry.costUsd ?? null,
+            durationSeconds: entry.durationSeconds ?? null,
+            timestamp: entry.timestamp,
+            metadata: {
+                ...(entry.metadata ?? {}),
+                ...(entry.commandName ? { commandName: entry.commandName } : {}),
+                ...(entry.action ? { action: entry.action } : {}),
+            },
+        };
+        const fileRecord = {
+            ...normalized,
+            ...(entry.commandName ? { commandName: entry.commandName } : {}),
+            ...(entry.action ? { action: entry.action } : {}),
+        };
+        await this.appendJsonArray(this.tokenUsagePath, fileRecord);
+        if (this.workspaceRepo) {
+            await this.workspaceRepo.recordTokenUsage(normalized);
+        }
+    }
+    async writeManifest(job, extras = {}) {
+        await PathHelper.ensureDir(this.jobDir(job.id));
+        const manifestPath = this.manifestPath(job.id);
+        const payload = {
+            schema_version: 1,
+            job_id: job.id,
+            updated_at: new Date().toISOString(),
+            status: job.status ?? job.state,
+            progress: { total: job.totalItems ?? null, completed: job.processedItems ?? null },
+            ...job,
+            ...extras,
+        };
+        await fs.writeFile(manifestPath, JSON.stringify(payload, null, 2), "utf8");
+    }
+    async close() {
+        if (this.workspaceRepo) {
+            await this.workspaceRepo.close();
+        }
+    }
+}

package/dist/services/jobs/JobsApiClient.d.ts

@@ -0,0 +1,73 @@
+import { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
+export interface JobsApiJob {
+    id: string;
+    type: string;
+    command_name?: string;
+    job_state?: string;
+    job_state_detail?: string;
+    job_state_detail_code?: string;
+    total_units?: number | null;
+    completed_units?: number | null;
+    created_at?: string;
+    updated_at?: string;
+    last_checkpoint_at?: string;
+    completed_at?: string | null;
+    payload_json?: unknown;
+}
+export interface JobsApiLogs {
+    entries: Array<{
+        timestamp: string;
+        sequence?: number | null;
+        level?: string | null;
+        source?: string | null;
+        message?: string | null;
+        task_id?: string | null;
+        task_key?: string | null;
+        phase?: string | null;
+        details?: Record<string, unknown> | null;
+    }>;
+    cursor?: {
+        timestamp: string;
+        sequence?: number | null;
+    };
+}
+export interface JobsApiTasksSummary {
+    totals: Record<string, number>;
+    tasks: Array<{
+        task_id?: string | null;
+        task_key?: string | null;
+        status?: string | null;
+        started_at?: string | null;
+        finished_at?: string | null;
+        command?: string | null;
+    }>;
+}
+export declare class JobsApiClient {
+    private workspace;
+    private baseUrl;
+    constructor(workspace: WorkspaceResolution, baseUrl: string);
+    private fetchJson;
+    private postJson;
+    listJobs(params: {
+        status?: string;
+        type?: string;
+        project?: string;
+        since?: string;
+        limit?: number;
+    }): Promise<JobsApiJob[] | undefined>;
+    getJob(jobId: string): Promise<JobsApiJob | undefined>;
+    getCheckpoint(jobId: string): Promise<Record<string, unknown> | undefined>;
+    getLogs(jobId: string, params: {
+        since?: string;
+        after?: {
+            timestamp: string;
+            sequence?: number | null;
+        };
+    }): Promise<JobsApiLogs | undefined>;
+    getTasksSummary(jobId: string): Promise<JobsApiTasksSummary | undefined>;
+    cancelJob(jobId: string, options?: {
+        force?: boolean;
+        reason?: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=JobsApiClient.d.ts.map

package/dist/services/jobs/JobsApiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JobsApiClient.d.ts","sourceRoot":"","sources":["../../../src/services/jobs/JobsApiClient.ts"],"names":[],"mappings":"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"}

package/dist/services/jobs/JobsApiClient.js

@@ -0,0 +1,67 @@
+export class JobsApiClient {
+    constructor(workspace, baseUrl) {
+        this.workspace = workspace;
+        this.baseUrl = baseUrl;
+    }
+    async fetchJson(path, query) {
+        try {
+            const url = new URL(path, this.baseUrl);
+            if (query) {
+                Object.entries(query).forEach(([key, value]) => {
+                    if (value === undefined)
+                        return;
+                    url.searchParams.set(key, String(value));
+                });
+            }
+            const resp = await fetch(url.toString(), { headers: { accept: "application/json" } });
+            if (!resp.ok)
+                return undefined;
+            return (await resp.json());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async postJson(path, body) {
+        try {
+            const resp = await fetch(new URL(path, this.baseUrl), {
+                method: "POST",
+                headers: { "content-type": "application/json", accept: "application/json" },
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            if (!resp.ok)
+                return undefined;
+            return (await resp.json());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async listJobs(params) {
+        return this.fetchJson("/jobs", params);
+    }
+    async getJob(jobId) {
+        return this.fetchJson(`/jobs/${jobId}`);
+    }
+    async getCheckpoint(jobId) {
+        return this.fetchJson(`/jobs/${jobId}/checkpoint`);
+    }
+    async getLogs(jobId, params) {
+        const sequence = params.after && typeof params.after.sequence === "number" ? params.after.sequence : undefined;
+        const after = params.after?.timestamp;
+        return this.fetchJson(`/jobs/${jobId}/logs`, {
+            since: params.since,
+            after: after || undefined,
+            sequence,
+        });
+    }
+    async getTasksSummary(jobId) {
+        return this.fetchJson(`/jobs/${jobId}/tasks/summary`);
+    }
+    async cancelJob(jobId, options = {}) {
+        await this.postJson(`/jobs/${jobId}/cancel`, {
+            force: options.force ?? false,
+            reason: options.reason ?? (options.force ? "force" : "user"),
+        });
+    }
+}

package/dist/services/openapi/OpenApiService.d.ts

@@ -0,0 +1,54 @@
+import { AgentService } from "@mcoda/agents";
+import { DocdexClient } from "@mcoda/integrations";
+import { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
+import { JobService } from "../jobs/JobService.js";
+import { RoutingService } from "../agents/RoutingService.js";
+export interface GenerateOpenapiOptions {
+    workspace: WorkspaceResolution;
+    agentName?: string;
+    agentStream?: boolean;
+    force?: boolean;
+    dryRun?: boolean;
+    validateOnly?: boolean;
+    cliVersion: string;
+    onToken?: (token: string) => void;
+    projectKey?: string;
+}
+export interface GenerateOpenapiResult {
+    jobId: string;
+    commandRunId: string;
+    outputPath?: string;
+    spec: string;
+    docdexId?: string;
+    warnings: string[];
+}
+export declare class OpenApiService {
+    private docdex;
+    private jobService;
+    private agentService;
+    private routingService;
+    private workspace;
+    constructor(workspace: WorkspaceResolution, deps: {
+        docdex?: DocdexClient;
+        jobService?: JobService;
+        agentService: AgentService;
+        routingService: RoutingService;
+        noTelemetry?: boolean;
+    });
+    static create(workspace: WorkspaceResolution, options?: {
+        noTelemetry?: boolean;
+    }): Promise<OpenApiService>;
+    close(): Promise<void>;
+    private resolveAgent;
+    private invokeAgent;
+    private sanitizeOutput;
+    private validateSpec;
+    private runOpenapiValidator;
+    private buildPrompt;
+    private ensureOpenapiDir;
+    private backupIfNeeded;
+    private registerOpenapi;
+    private validateExistingSpec;
+    generateFromDocs(options: GenerateOpenapiOptions): Promise<GenerateOpenapiResult>;
+}
+//# sourceMappingURL=OpenApiService.d.ts.map