@mcoda/core 0.1.4

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

@@ -0,0 +1 @@
+{"version":3,"file":"OpenApiService.d.ts","sourceRoot":"","sources":["../../../src/services/openapi/OpenApiService.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAkB,MAAM,qBAAqB,CAAC;AAGnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AA0MD,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,SAAS,CAAsB;gBAGrC,SAAS,EAAE,mBAAmB,EAC9B,IAAI,EAAE;QAAE,MAAM,CAAC,EAAE,YAAY,CAAC;QAAC,UAAU,CAAC,EAAE,UAAU,CAAC;QAAC,YAAY,EAAE,YAAY,CAAC;QAAC,cAAc,EAAE,cAAc,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE;WAShI,MAAM,CAAC,SAAS,EAAE,mBAAmB,EAAE,OAAO,GAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IAY/G,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAKd,YAAY;YASZ,WAAW;IA8BzB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,YAAY;YAaN,mBAAmB;IAajC,OAAO,CAAC,WAAW;YAwBL,gBAAgB;YAMhB,cAAc;YAOd,eAAe;YAef,oBAAoB;IAS5B,gBAAgB,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CA0JxF"}

package/dist/services/openapi/OpenApiService.js

@@ -0,0 +1,503 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import YAML from "yaml";
+import SwaggerParser from "@apidevtools/swagger-parser";
+import { AgentService } from "@mcoda/agents";
+import { DocdexClient } from "@mcoda/integrations";
+import { GlobalRepository } from "@mcoda/db";
+import { JobService } from "../jobs/JobService.js";
+import { RoutingService } from "../agents/RoutingService.js";
+const OPENAPI_TAGS = [
+// For project-specific specs, tags come from context; this is only a fallback.
+];
+const OPENAPI_VERSION = "3.1.0";
+const CONTEXT_TOKEN_BUDGET = 8000;
+const estimateTokens = (text) => Math.max(1, Math.ceil(text.length / 4));
+const fileExists = async (candidate) => {
+    try {
+        await fs.access(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const readGitBranch = async (workspaceRoot) => {
+    const headPath = path.join(workspaceRoot, ".git", "HEAD");
+    try {
+        const content = await fs.readFile(headPath, "utf8");
+        const match = content.match(/ref: refs\/heads\/(.+)/);
+        return match ? match[1].trim() : content.trim();
+    }
+    catch {
+        return undefined;
+    }
+};
+class OpenapiContextAssembler {
+    constructor(docdex, workspace, projectKey) {
+        this.docdex = docdex;
+        this.workspace = workspace;
+        this.projectKey = projectKey;
+    }
+    summarize(doc) {
+        const text = doc.content ?? "";
+        if (!text)
+            return doc.title ?? doc.path ?? doc.id ?? "Document";
+        return text.split(/\r?\n/).slice(0, 5).join(" ").slice(0, 400);
+    }
+    async findLatestLocalDoc(docType) {
+        const candidates = [];
+        const dirNames = [".mcoda/docs", "docs"];
+        for (const dir of dirNames) {
+            const target = path.join(this.workspace.workspaceRoot, dir, docType.toLowerCase());
+            try {
+                const entries = await fs.readdir(target);
+                for (const entry of entries.filter((e) => e.endsWith(".md"))) {
+                    const full = path.join(target, entry);
+                    const stat = await fs.stat(full);
+                    candidates.push({ path: full, mtime: stat.mtimeMs });
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        const latest = candidates.sort((a, b) => b.mtime - a.mtime)[0];
+        if (!latest)
+            return undefined;
+        const content = await fs.readFile(latest.path, "utf8");
+        const timestamp = new Date(latest.mtime).toISOString();
+        return {
+            id: `local-${docType.toLowerCase()}-${path.basename(latest.path)}`,
+            docType,
+            path: latest.path,
+            content,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+    }
+    formatBlock(doc, label, priority, maxSegments = 5) {
+        const segments = (doc.segments ?? []).slice(0, maxSegments);
+        const heading = `[${doc.docType}] ${label}`;
+        const source = doc.path ?? doc.id ?? label;
+        const body = segments.length
+            ? segments
+                .map((seg, idx) => {
+                const head = seg.heading ?? `Segment ${idx + 1}`;
+                const trimmed = seg.content.length > 1000 ? `${seg.content.slice(0, 1000)}...` : seg.content;
+                return `### ${head}\n${trimmed}`;
+            })
+                .join("\n\n")
+            : doc.content ?? this.summarize(doc);
+        const content = [heading, `Source: ${source}`, body].filter(Boolean).join("\n");
+        return {
+            label,
+            content,
+            priority,
+            tokens: estimateTokens(content),
+        };
+    }
+    enforceBudget(blocks, warnings) {
+        let total = blocks.reduce((sum, b) => sum + b.tokens, 0);
+        if (total <= CONTEXT_TOKEN_BUDGET)
+            return blocks;
+        const ordered = [...blocks].sort((a, b) => a.priority - b.priority);
+        for (const block of ordered) {
+            if (total <= CONTEXT_TOKEN_BUDGET)
+                break;
+            const summary = `${block.label}: ${block.content.slice(0, 400)}`;
+            total -= block.tokens;
+            block.content = summary;
+            block.tokens = estimateTokens(summary);
+            total += block.tokens;
+            warnings.push(`Context for ${block.label} truncated to fit budget.`);
+        }
+        return blocks;
+    }
+    async build() {
+        const warnings = [];
+        const blocks = [];
+        let docdexAvailable = true;
+        let sdsDocs = [];
+        let pdrDocs = [];
+        let rfpDocs = [];
+        let openapiDocs = [];
+        let schemaDocs = [];
+        try {
+            [sdsDocs, pdrDocs, rfpDocs, openapiDocs, schemaDocs] = await Promise.all([
+                this.docdex.search({ docType: "SDS", profile: "openapi", projectKey: this.projectKey }),
+                this.docdex.search({ docType: "PDR", profile: "openapi", projectKey: this.projectKey }),
+                this.docdex.search({ docType: "RFP", profile: "openapi", projectKey: this.projectKey }),
+                this.docdex.search({ docType: "OPENAPI", profile: "openapi", projectKey: this.projectKey }),
+                this.docdex.search({ docType: "Architecture", profile: "openapi", projectKey: this.projectKey }),
+            ]);
+        }
+        catch (error) {
+            docdexAvailable = false;
+            warnings.push(`Docdex unavailable; falling back to local docs for OpenAPI context (${error.message ?? "unknown"})`);
+        }
+        // Fallbacks when docdex returns no hits
+        if (sdsDocs.length === 0) {
+            const local = await this.findLatestLocalDoc("SDS");
+            if (local) {
+                blocks.push(this.formatBlock(local, "Local SDS (no docdex)", 1, 8));
+                warnings.push("No SDS found in docdex; using latest local SDS file.");
+                sdsDocs = [local];
+            }
+            else {
+                warnings.push("No SDS found in docdex or local workspace.");
+            }
+        }
+        else {
+            blocks.push(this.formatBlock(sdsDocs[0], "SDS OpenAPI contract", 1, 8));
+        }
+        if (pdrDocs.length === 0) {
+            const local = await this.findLatestLocalDoc("PDR");
+            if (local) {
+                blocks.push(this.formatBlock(local, "Local PDR (no docdex)", 2, 6));
+                warnings.push("No PDR found in docdex; using latest local PDR file.");
+                pdrDocs = [local];
+            }
+            else {
+                warnings.push("No PDR found in docdex or local workspace.");
+            }
+        }
+        else {
+            blocks.push(this.formatBlock(pdrDocs[0], "PDR context", 2, 6));
+        }
+        if (rfpDocs.length === 0) {
+            const local = await this.findLatestLocalDoc("RFP");
+            if (local) {
+                blocks.push(this.formatBlock(local, "Local RFP (no docdex)", 2, 6));
+                warnings.push("No RFP found in docdex; using latest local RFP file.");
+                rfpDocs = [local];
+            }
+            else {
+                warnings.push("No RFP found in docdex or local workspace.");
+            }
+        }
+        else {
+            blocks.push(this.formatBlock(rfpDocs[0], "RFP alignment", 2, 6));
+        }
+        if (openapiDocs.length > 0) {
+            blocks.push(this.formatBlock(openapiDocs[0], "Existing OpenAPI docdex", 1, 6));
+        }
+        if (schemaDocs.length > 0) {
+            blocks.push(this.formatBlock(schemaDocs[0], "Data model & persistence", 1, 6));
+        }
+        if (!blocks.length) {
+            const localSds = await this.findLatestLocalDoc("SDS");
+            if (localSds)
+                blocks.push(this.formatBlock(localSds, "Local SDS", 1, 6));
+            const localPdr = await this.findLatestLocalDoc("PDR");
+            if (localPdr)
+                blocks.push(this.formatBlock(localPdr, "Local PDR", 2, 6));
+        }
+        return {
+            blocks: this.enforceBudget(blocks, warnings),
+            docdexAvailable,
+            warnings,
+        };
+    }
+}
+export class OpenApiService {
+    constructor(workspace, deps) {
+        this.workspace = workspace;
+        this.docdex = deps?.docdex ?? new DocdexClient({ workspaceRoot: workspace.workspaceRoot });
+        this.jobService = deps?.jobService ?? new JobService(workspace, undefined, { noTelemetry: deps?.noTelemetry });
+        this.agentService = deps.agentService;
+        this.routingService = deps.routingService;
+    }
+    static async create(workspace, options = {}) {
+        const repo = await GlobalRepository.create();
+        const agentService = new AgentService(repo);
+        const routingService = await RoutingService.create();
+        const docdex = new DocdexClient({
+            workspaceRoot: workspace.workspaceRoot,
+            baseUrl: workspace.config?.docdexUrl ?? process.env.MCODA_DOCDEX_URL,
+        });
+        const jobService = new JobService(workspace, undefined, { noTelemetry: options.noTelemetry });
+        return new OpenApiService(workspace, { agentService, routingService, docdex, jobService, noTelemetry: options.noTelemetry });
+    }
+    async close() {
+        if (this.agentService.close)
+            await this.agentService.close();
+        if (this.jobService.close)
+            await this.jobService.close();
+    }
+    async resolveAgent(agentName) {
+        const resolved = await this.routingService.resolveAgentForCommand({
+            workspace: this.workspace,
+            commandName: "openapi-from-docs",
+            overrideAgentSlug: agentName,
+        });
+        return resolved.agent;
+    }
+    async invokeAgent(agent, prompt, stream, jobId, onToken) {
+        if (stream) {
+            try {
+                const generator = await this.agentService.invokeStream(agent.id, { input: prompt, metadata: { jobId } });
+                const chunks = [];
+                for await (const chunk of generator) {
+                    chunks.push(chunk.output);
+                    await this.jobService.appendLog(jobId, chunk.output);
+                    if (onToken)
+                        onToken(chunk.output);
+                }
+                return { output: chunks.join(""), adapter: agent.adapter };
+            }
+            catch {
+                const fallback = await this.agentService.invoke(agent.id, { input: prompt, metadata: { jobId } });
+                await this.jobService.appendLog(jobId, fallback.output);
+                if (onToken)
+                    onToken(fallback.output);
+                return { output: fallback.output, adapter: fallback.adapter, metadata: fallback.metadata };
+            }
+        }
+        const result = await this.agentService.invoke(agent.id, { input: prompt, metadata: { jobId } });
+        await this.jobService.appendLog(jobId, result.output);
+        if (onToken)
+            onToken(result.output);
+        return { output: result.output, adapter: result.adapter, metadata: result.metadata };
+    }
+    sanitizeOutput(raw) {
+        const trimmed = raw.trim();
+        if (trimmed.startsWith("```")) {
+            const withoutFence = trimmed.replace(/^```[a-zA-Z]*\s*/m, "").replace(/```$/, "");
+            return withoutFence.trim();
+        }
+        return trimmed;
+    }
+    validateSpec(doc) {
+        const errors = [];
+        if (!doc || typeof doc !== "object") {
+            errors.push("Spec is not a YAML object.");
+            return errors;
+        }
+        if (!doc.openapi)
+            errors.push("Missing openapi version");
+        if (!doc.info?.title)
+            errors.push("Missing info.title");
+        if (!doc.info?.version)
+            errors.push("Missing info.version");
+        if (!doc.paths)
+            errors.push("paths section is required (can be empty if no HTTP API)");
+        return errors;
+    }
+    async runOpenapiValidator(doc) {
+        try {
+            await SwaggerParser.validate(doc);
+            return [];
+        }
+        catch (error) {
+            const details = error?.details;
+            if (Array.isArray(details) && details.length) {
+                return details.map((d) => d.message ?? String(error));
+            }
+            return [error.message];
+        }
+    }
+    buildPrompt(context, cliVersion, retryReasons) {
+        const contextBlocks = context.blocks
+            .map((block) => `### ${block.label}\n${block.content}`)
+            .join("\n\n");
+        const retryNote = retryReasons?.length
+            ? `\nPrevious attempt issues:\n${retryReasons.map((r) => `- ${r}`).join("\n")}\nFix them in this draft.\n`
+            : "";
+        return [
+            "You are generating an OpenAPI 3.1 YAML for THIS workspace/project using only the provided PDR/SDS/RFP context.",
+            "Derive resources, schemas, and HTTP endpoints directly from the product requirements (e.g., todos CRUD, filters, search, bulk actions).",
+            "If the documents describe a frontend-only/localStorage app, design a minimal REST API that could back those features (e.g., /todos, /todos/{id}, bulk operations, search/filter params) instead of returning an empty spec.",
+            "Prefer concise tags derived from domain resources (e.g., Todos). Avoid generic mcoda/system endpoints unless explicitly described in the context.",
+            `Use OpenAPI version ${OPENAPI_VERSION}, set info.title to the project name from context (fallback \"mcoda API\"), and info.version ${cliVersion}.`,
+            "Return only valid YAML (no Markdown fences, no commentary).",
+            retryNote,
+            "Scope rules:",
+            "- Derive endpoints, schemas, and tags from the provided PDR/SDS/RFP context only.",
+            "- Do NOT emit generic mcoda CLI/system endpoints unless explicitly described.",
+            "- Prefer concise schemas and operations that map to described APIs; omit unused boilerplate.",
+            "Context:",
+            contextBlocks || "No context available; if none, produce a minimal empty spec with paths: {}.",
+        ].join("\n\n");
+    }
+    async ensureOpenapiDir() {
+        const dir = path.join(this.workspace.workspaceRoot, "openapi");
+        await fs.mkdir(dir, { recursive: true });
+        return dir;
+    }
+    async backupIfNeeded(target) {
+        if (!(await fileExists(target)))
+            return undefined;
+        const backup = `${target}.bak`;
+        await fs.copyFile(target, backup);
+        return backup;
+    }
+    async registerOpenapi(outPath, content) {
+        const branch = this.workspace.config?.branch ?? (await readGitBranch(this.workspace.workspaceRoot));
+        return this.docdex.registerDocument({
+            docType: "OPENAPI",
+            path: outPath,
+            content,
+            metadata: {
+                workspace: this.workspace.workspaceId,
+                branch,
+                status: "canonical",
+                projectKey: this.workspace.config?.projectKey,
+            },
+        });
+    }
+    async validateExistingSpec(target) {
+        const content = await fs.readFile(target, "utf8");
+        const parsed = YAML.parse(content);
+        const issues = this.validateSpec(parsed);
+        const validatorIssues = await this.runOpenapiValidator(parsed);
+        issues.push(...validatorIssues);
+        return { spec: content, issues };
+    }
+    async generateFromDocs(options) {
+        const commandRun = await this.jobService.startCommandRun("openapi-from-docs", options.projectKey);
+        const job = await this.jobService.startJob("openapi_change", commandRun.id, options.projectKey, {
+            commandName: commandRun.commandName,
+            payload: { workspaceRoot: this.workspace.workspaceRoot, projectKey: options.projectKey },
+        });
+        const warnings = [];
+        try {
+            const projectKey = options.projectKey ?? this.workspace.config?.projectKey;
+            const assembler = new OpenapiContextAssembler(this.docdex, this.workspace, projectKey);
+            const context = await assembler.build();
+            warnings.push(...context.warnings);
+            await this.jobService.writeCheckpoint(job.id, {
+                stage: "context_built",
+                timestamp: new Date().toISOString(),
+                details: { docdexAvailable: context.docdexAvailable },
+            });
+            await this.jobService.recordTokenUsage({
+                timestamp: new Date().toISOString(),
+                workspaceId: this.workspace.workspaceId,
+                commandName: "openapi-from-docs",
+                jobId: job.id,
+                action: "docdex_context",
+                promptTokens: 0,
+                completionTokens: 0,
+                metadata: { docdexAvailable: context.docdexAvailable },
+            });
+            const openapiDir = await this.ensureOpenapiDir();
+            const outputPath = path.join(openapiDir, "mcoda.yaml");
+            if (options.validateOnly) {
+                if (!(await fileExists(outputPath))) {
+                    throw new Error(`Cannot validate missing spec: ${outputPath}`);
+                }
+                const { spec, issues } = await this.validateExistingSpec(outputPath);
+                const validationNote = issues.length ? `Validation issues:\n${issues.join("\n")}` : "Validation passed.";
+                await this.jobService.appendLog(job.id, `${validationNote}\n`);
+                const jobState = issues.length ? "failed" : "completed";
+                const commandState = issues.length ? "failed" : "succeeded";
+                await this.jobService.updateJobStatus(job.id, jobState, { payload: { validation: validationNote } });
+                await this.jobService.finishCommandRun(commandRun.id, commandState, issues.join("; "));
+                return {
+                    jobId: job.id,
+                    commandRunId: commandRun.id,
+                    outputPath,
+                    spec,
+                    warnings,
+                };
+            }
+            if (!options.force && (await fileExists(outputPath))) {
+                throw new Error(`File exists, use --force to overwrite (${outputPath})`);
+            }
+            const agent = await this.resolveAgent(options.agentName);
+            const stream = options.agentStream ?? true;
+            let specYaml = "";
+            let parsed;
+            let adapter = agent.adapter;
+            let agentMetadata;
+            let lastErrors;
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const prompt = this.buildPrompt(context, options.cliVersion, lastErrors);
+                const { output, adapter: usedAdapter, metadata } = await this.invokeAgent(agent, prompt, stream, job.id, options.onToken);
+                adapter = usedAdapter;
+                agentMetadata = metadata;
+                specYaml = this.sanitizeOutput(output);
+                try {
+                    parsed = YAML.parse(specYaml);
+                    if (!parsed.info)
+                        parsed.info = {};
+                    const projectTitle = options.projectKey ?? this.workspace.config?.projectKey;
+                    parsed.info.title = parsed.info.title ?? projectTitle ?? "mcoda API";
+                    parsed.info.version = options.cliVersion;
+                    parsed.openapi = parsed.openapi ?? OPENAPI_VERSION;
+                    const errors = this.validateSpec(parsed);
+                    const validatorErrors = await this.runOpenapiValidator(parsed);
+                    errors.push(...validatorErrors);
+                    await this.jobService.recordTokenUsage({
+                        timestamp: new Date().toISOString(),
+                        workspaceId: this.workspace.workspaceId,
+                        commandName: "openapi-from-docs",
+                        jobId: job.id,
+                        agentId: agent.id,
+                        modelName: agent.defaultModel,
+                        action: attempt === 0 ? "draft_openapi" : "draft_openapi_retry",
+                        promptTokens: estimateTokens(prompt),
+                        completionTokens: estimateTokens(output),
+                        metadata: { adapter, provider: adapter, attempt },
+                    });
+                    if (errors.length === 0) {
+                        specYaml = YAML.stringify(parsed);
+                        break;
+                    }
+                    if (attempt === 1) {
+                        throw new Error(`Generated spec failed validation: ${errors.join("; ")}`);
+                    }
+                    lastErrors = errors;
+                }
+                catch (error) {
+                    if (attempt === 1) {
+                        throw new Error(error.message || "Failed to parse generated YAML");
+                    }
+                    lastErrors = [error.message ?? "Invalid YAML"];
+                }
+            }
+            let backup;
+            if (!options.dryRun) {
+                backup = await this.backupIfNeeded(outputPath);
+                await fs.writeFile(outputPath, specYaml, "utf8");
+            }
+            else {
+                warnings.push("Dry run enabled; spec not written to disk.");
+            }
+            let docdexId;
+            if (!options.dryRun && context.docdexAvailable) {
+                try {
+                    const registered = await this.registerOpenapi(outputPath, specYaml);
+                    docdexId = registered.id;
+                }
+                catch (error) {
+                    warnings.push(`Docdex registration skipped: ${error.message}`);
+                }
+            }
+            await this.jobService.updateJobStatus(job.id, "completed", {
+                payload: {
+                    outputPath,
+                    backupPath: backup,
+                    docdexId,
+                    adapter,
+                    agentMetadata,
+                },
+            });
+            await this.jobService.finishCommandRun(commandRun.id, "succeeded");
+            return {
+                jobId: job.id,
+                commandRunId: commandRun.id,
+                outputPath: options.dryRun ? undefined : outputPath,
+                spec: specYaml,
+                docdexId,
+                warnings,
+            };
+        }
+        catch (error) {
+            await this.jobService.updateJobStatus(job.id, "failed", { errorSummary: error.message });
+            await this.jobService.finishCommandRun(commandRun.id, "failed", error.message);
+            throw error;
+        }
+    }
+}

package/dist/services/planning/CreateTasksService.d.ts

@@ -0,0 +1,68 @@
+import { AgentService } from "@mcoda/agents";
+import { EpicRow, GlobalRepository, StoryRow, TaskDependencyRow, TaskRow, WorkspaceRepository } from "@mcoda/db";
+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 CreateTasksOptions {
+    workspace: WorkspaceResolution;
+    projectKey: string;
+    inputs: string[];
+    agentName?: string;
+    agentStream?: boolean;
+    maxEpics?: number;
+    maxStoriesPerEpic?: number;
+    maxTasksPerStory?: number;
+    force?: boolean;
+}
+export interface CreateTasksResult {
+    jobId: string;
+    commandRunId: string;
+    epics: EpicRow[];
+    stories: StoryRow[];
+    tasks: TaskRow[];
+    dependencies: TaskDependencyRow[];
+}
+export declare class CreateTasksService {
+    private static readonly MAX_BUSY_RETRIES;
+    private static readonly BUSY_BACKOFF_MS;
+    private docdex;
+    private jobService;
+    private agentService;
+    private repo;
+    private workspaceRepo;
+    private routingService;
+    private workspace;
+    constructor(workspace: WorkspaceResolution, deps: {
+        docdex: DocdexClient;
+        jobService: JobService;
+        agentService: AgentService;
+        repo: GlobalRepository;
+        workspaceRepo: WorkspaceRepository;
+        routingService: RoutingService;
+    });
+    static create(workspace: WorkspaceResolution): Promise<CreateTasksService>;
+    close(): Promise<void>;
+    private resolveAgent;
+    private prepareDocs;
+    private buildDocContext;
+    private buildPrompt;
+    private fallbackPlan;
+    private invokeAgentWithRetry;
+    private parseEpics;
+    private generateStoriesForEpic;
+    private generateTasksForStory;
+    private generatePlanFromAgent;
+    private writePlanArtifacts;
+    private persistPlanToDb;
+    createTasks(options: CreateTasksOptions): Promise<CreateTasksResult>;
+    migratePlanFromFolder(options: {
+        projectKey: string;
+        planDir?: string;
+        force?: boolean;
+        refinePlanPath?: string;
+        refinePlanPaths?: string[];
+        refinePlansDir?: string;
+    }): Promise<CreateTasksResult>;
+}
+//# sourceMappingURL=CreateTasksService.d.ts.map

package/dist/services/planning/CreateTasksService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateTasksService.d.ts","sourceRoot":"","sources":["../../../src/services/planning/CreateTasksService.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAEL,OAAO,EACP,gBAAgB,EAEhB,QAAQ,EAER,iBAAiB,EAEjB,OAAO,EACP,mBAAmB,EACpB,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,YAAY,EAAkB,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAO7D,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,YAAY,EAAE,iBAAiB,EAAE,CAAC;CACnC;AA4QD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAK;IAC7C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAO;IAC9C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,IAAI,CAAmB;IAC/B,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,SAAS,CAAsB;gBAGrC,SAAS,EAAE,mBAAmB,EAC9B,IAAI,EAAE;QACJ,MAAM,EAAE,YAAY,CAAC;QACrB,UAAU,EAAE,UAAU,CAAC;QACvB,YAAY,EAAE,YAAY,CAAC;QAC3B,IAAI,EAAE,gBAAgB,CAAC;QACvB,aAAa,EAAE,mBAAmB,CAAC;QACnC,cAAc,EAAE,cAAc,CAAC;KAChC;WAWU,MAAM,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAoB1E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAiBd,YAAY;YASZ,WAAW;IAmCzB,OAAO,CAAC,eAAe;IAgCvB,OAAO,CAAC,WAAW;IA+BnB,OAAO,CAAC,YAAY;YAkDN,oBAAoB;IAuElC,OAAO,CAAC,UAAU;YAmBJ,sBAAsB;YA0CtB,qBAAqB;YA6CrB,qBAAqB;YAyDrB,kBAAkB;YAkBlB,eAAe;IA4MvB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAwIpE,qBAAqB,CAAC,OAAO,EAAE;QACnC,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;QAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,GAAG,OAAO,CAAC,iBAAiB,CAAC;CA6I/B"}