@sireai/optimus 0.1.1 → 0.1.2

package/dist/cli/optimus.js

@@ -33,6 +33,7 @@ const CLI_ROOT_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", ".."
 const PACKAGE_JSON_PATH = join(CLI_ROOT_DIR, "package.json");
 const execFileAsync = promisify(execFile);
 const PACKAGE_NAME = "@sireai/optimus";
+const JIRA_CLI_ENTRY = join(CLI_ROOT_DIR, "dist", "integrations", "jira", "jira-cli.js");
 function renderSetupResult(result) {
     const lines = [];
     lines.push("Setup Complete");
@@ -162,7 +163,7 @@ function renderCliHelp() {
         "",
         "Integration commands:",
         "  intake-status|intake-run|intake-disable|intake-enable|intake-reset-checkpoint",
-        "  jira-search|jira-get-issue|jira-search-assigned-open|jira-submit-issue|jira-submit-assigned-open|jira-poll-once|jira-poll-daemon",
+        "  jira-search|jira-get-issue|jira-search-assigned-open|jira-submit-issue|jira-submit-assigned-open|jira-add-comment|jira-poll-once|jira-poll-daemon",
         "",
         "Global options:",
         "  -h, --help            Show this help",
@@ -173,24 +174,125 @@ function renderCliHelp() {
         `  - Run \`optimus setup\` once; Optimus stores config and runtime data under ${resolveOptimusHomeDir()}.`
     ].join("\n");
 }
+function mapJiraCommand(command) {
+    switch (command) {
+        case "jira-search":
+            return "search";
+        case "jira-get-issue":
+            return "get-issue";
+        case "jira-search-assigned-open":
+            return "search-assigned-open";
+        case "jira-submit-issue":
+            return "submit-issue";
+        case "jira-submit-assigned-open":
+            return "submit-assigned-open";
+        case "jira-add-comment":
+            return "add-comment";
+        case "jira-poll-once":
+            return "poll-once";
+        case "jira-poll-daemon":
+            return "poll-daemon";
+        default:
+            return undefined;
+    }
+}
+function resolveJiraQuickDoctorIssues(config) {
+    const issues = [];
+    if (!config.baseUrl?.trim() || /jira\.example\.com/i.test(config.baseUrl)) {
+        issues.push({
+            code: "jira_base_url_missing",
+            message: "Jira integration is enabled, but Jira base URL is missing or still using the placeholder value.",
+            fix: "Rerun `optimus setup` and provide a real Jira base URL."
+        });
+    }
+    if (config.authType === "bearer") {
+        if (!config.bearerToken?.trim()) {
+            issues.push({
+                code: "jira_token_missing",
+                message: "Jira integration is enabled, but Jira bearer token is missing.",
+                fix: "Rerun `optimus setup` and provide a Jira token."
+            });
+        }
+        return issues;
+    }
+    if (config.authType === "basic") {
+        if (!config.username?.trim() || !(config.apiToken?.trim() || config.password?.trim())) {
+            issues.push({
+                code: "jira_basic_auth_missing",
+                message: "Jira integration is enabled, but Jira basic auth credentials are incomplete.",
+                fix: "Provide Jira username plus api token or password, then rerun `optimus doctor --quick`."
+            });
+        }
+        return issues;
+    }
+    if (!config.mcpUrl?.trim() || /jira-mcp\.example\.com/i.test(config.mcpUrl)) {
+        issues.push({
+            code: "jira_mcp_url_missing",
+            message: "Jira integration is enabled, but Jira MCP URL is missing or still using the placeholder value.",
+            fix: "Provide a real Jira MCP URL, then rerun `optimus doctor --quick`."
+        });
+    }
+    const requiredHeaders = [
+        "X-Atlassian-Jira-Url",
+        "X-Atlassian-Username",
+        "X-Atlassian-Jira-Personal-Token"
+    ];
+    const missingHeaders = requiredHeaders.filter((name) => !config.httpHeaders[name]?.trim());
+    if (missingHeaders.length > 0) {
+        issues.push({
+            code: "jira_mcp_headers_missing",
+            message: `Jira integration is enabled, but Jira MCP headers are incomplete: ${missingHeaders.join(", ")}.`,
+            fix: "Provide the required Jira MCP headers, then rerun `optimus doctor --quick`."
+        });
+    }
+    return issues;
+}
+async function forwardJiraCliCommand(command, commandArgs) {
+    const mappedCommand = mapJiraCommand(command);
+    if (!mappedCommand) {
+        throw new Error(`Unsupported Jira command forwarding target: ${command}`);
+    }
+    const jiraCliEntry = process.env.OPTIMUS_JIRA_CLI_ENTRY?.trim() || JIRA_CLI_ENTRY;
+    return await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(process.execPath, [jiraCliEntry, mappedCommand, ...commandArgs], {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: "inherit"
+        });
+        child.on("error", rejectPromise);
+        child.on("close", (code) => {
+            resolvePromise(code ?? 1);
+        });
+    });
+}
 async function readPackageVersion() {
     const raw = await readFile(PACKAGE_JSON_PATH, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.version?.trim() || "0.0.0";
 }
-async function rerunCurrentCommand() {
-    const scriptPath = process.argv[1];
-    if (!scriptPath) {
-        throw new Error("Unable to resolve current Optimus entry script.");
-    }
-    return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [scriptPath, ...process.argv.slice(2)], {
-            stdio: "inherit",
-            env: process.env
-        });
-        child.on("error", reject);
-        child.on("close", (code) => resolve(code ?? 1));
-    });
+function isInteractiveSelfUpdatePromptAllowed() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+async function promptForStartupSelfUpdate(currentVersion, latestVersion) {
+    const rl = createInterface({ input, output });
+    try {
+        console.log(`[optimus] update available ${currentVersion} -> ${latestVersion}.`);
+        console.log("1. Upgrade now and exit");
+        console.log("2. Continue with current version");
+        while (true) {
+            const answer = (await rl.question("Select [1/2] (default 2): ")).trim().toLowerCase();
+            if (!answer || answer === "2" || answer === "c" || answer === "continue") {
+                return "continue";
+            }
+            if (answer === "1" || answer === "u" || answer === "upgrade") {
+                return "upgrade";
+            }
+            console.log("Invalid selection. Enter 1 to upgrade or 2 to continue.");
+        }
+    }
+    finally {
+        rl.close();
+    }
 }
 async function maybeHandleStartupSelfUpdate(input) {
     const check = await checkForSelfUpdate({
@@ -222,7 +324,28 @@ async function maybeHandleStartupSelfUpdate(input) {
     if (!check.updateAvailable || !check.latestVersion) {
         return { handled: false };
     }
-    if ((input.config.selfUpdate ?? buildDefaultConfig().selfUpdate).mode !== "auto" || input.command !== "start") {
+    const selfUpdateConfig = input.config.selfUpdate ?? buildDefaultConfig().selfUpdate;
+    if (input.command !== "start") {
+        console.log(`[optimus] update available ${check.currentVersion} -> ${check.latestVersion}. Run \`optimus upgrade\`.`);
+        return { handled: false };
+    }
+    if (selfUpdateConfig.mode === "prompt") {
+        if (!isInteractiveSelfUpdatePromptAllowed()) {
+            console.log(`[optimus] update available ${check.currentVersion} -> ${check.latestVersion}. Run \`optimus upgrade\`.`);
+            return { handled: false };
+        }
+        const choice = await promptForStartupSelfUpdate(check.currentVersion, check.latestVersion);
+        await input.logger.info("self_update.prompt_resolved", {
+            command: input.command,
+            currentVersion: check.currentVersion,
+            latestVersion: check.latestVersion,
+            choice
+        });
+        if (choice === "continue") {
+            return { handled: false };
+        }
+    }
+    else if (selfUpdateConfig.mode !== "auto") {
         console.log(`[optimus] update available ${check.currentVersion} -> ${check.latestVersion}. Run \`optimus upgrade\`.`);
         return { handled: false };
     }
@@ -245,7 +368,10 @@ async function maybeHandleStartupSelfUpdate(input) {
             latestVersion: check.latestVersion,
             reason: install.state.lastError ?? install.reason ?? "unknown"
         });
-        console.log(`[optimus] upgrade failed, continuing with ${check.currentVersion}.`);
+        console.log(`[optimus] upgrade failed. Continue with ${check.currentVersion}, or run \`optimus upgrade\` after fixing npm access.`);
+        if (selfUpdateConfig.mode === "auto") {
+            return { handled: true, exitCode: 1 };
+        }
         return { handled: false };
     }
     await input.logger.info("self_update.install_succeeded", {
@@ -253,10 +379,10 @@ async function maybeHandleStartupSelfUpdate(input) {
         currentVersion: check.currentVersion,
         latestVersion: check.latestVersion
     });
-    console.log(`[optimus] upgrade succeeded, restarting ${input.command}...`);
+    console.log(`[optimus] upgrade succeeded. Restart with \`optimus ${input.command}\`.`);
     return {
         handled: true,
-        exitCode: await rerunCurrentCommand()
+        exitCode: 0
     };
 }
 async function pathExists(path) {
@@ -839,20 +965,9 @@ async function runQuickDoctor(configPath = resolveDefaultConfigPath()) {
         });
     }
     if (config.jira.enabled) {
-        if (!config.jira.baseUrl?.trim() || /jira\.example\.com/i.test(config.jira.baseUrl)) {
-            blocking.push({
-                code: "jira_base_url_missing",
-                message: "Jira integration is enabled, but Jira base URL is missing or still using the placeholder value.",
-                fix: "Rerun `optimus setup` and provide a real Jira base URL."
-            });
-            next.add("optimus setup");
-        }
-        if (!config.jira.bearerToken?.trim()) {
-            blocking.push({
-                code: "jira_token_missing",
-                message: "Jira integration is enabled, but Jira token is missing.",
-                fix: "Rerun `optimus setup` and provide a Jira token."
-            });
+        const jiraIssues = resolveJiraQuickDoctorIssues(config.jira);
+        blocking.push(...jiraIssues);
+        if (jiraIssues.length > 0) {
             next.add("optimus setup");
         }
     }
@@ -890,7 +1005,18 @@ async function runSetup(args) {
     if (!inspection.ok) {
         throw new Error(`Repository path is not usable: ${normalizedRepoPath} (${inspection.reason ?? "unknown"})`);
     }
-    const previewExecutionPlan = describeRepositoryExecutionPlan({ executionMode: "copy" }, inspection);
+    const preflightConfig = configExists ? await loadConfig(configPath) : buildDefaultConfig();
+    const preflightStore = new SQLiteTaskStore(preflightConfig.storage.rootDir);
+    await preflightStore.init();
+    const existingRepositories = await preflightStore.listRepositoryRoots();
+    const aliasConflict = existingRepositories.find((repository) => repository.alias === answers.repoAlias && repository.path !== normalizedRepoPath);
+    if (aliasConflict) {
+        throw new Error(`Repository alias already exists for another path: ${answers.repoAlias} -> ${aliasConflict.path}. `
+            + "Use `optimus repo update` or `optimus repo remove` before re-running setup.");
+    }
+    const existingRepository = existingRepositories.find((repository) => repository.path === normalizedRepoPath);
+    const resolvedExecutionMode = existingRepository?.executionMode ?? describeRepositoryExecutionPlan({ executionMode: "copy" }, inspection).resolvedDefaultMode;
+    const previewExecutionPlan = describeRepositoryExecutionPlan({ executionMode: resolvedExecutionMode }, inspection);
     const reviewSystem = await detectRepositoryReviewSystem(normalizedRepoPath, inspection);
     await mkdir(dirname(configPath), { recursive: true });
     await writeFile(configPath, `${buildSetupConfig({ ...answers, repoPath: normalizedRepoPath })}\n`, "utf8");
@@ -902,14 +1028,10 @@ async function runSetup(args) {
     const config = await loadConfig(configPath);
     const store = new SQLiteTaskStore(config.storage.rootDir);
     await store.init();
-    const existingRepositories = await store.listRepositoryRoots();
-    for (const repository of existingRepositories) {
-        await store.removeRepositoryRoot(repository.path);
-    }
     await store.addRepositoryRoot({
         path: normalizedRepoPath,
         alias: answers.repoAlias,
-        executionMode: previewExecutionPlan.resolvedDefaultMode
+        executionMode: resolvedExecutionMode
     });
     const doctorQuick = await runQuickDoctor(configPath);
     const codexAuth = new CodexAuthResolver(config).resolve().diagnostics;
@@ -922,7 +1044,7 @@ async function runSetup(args) {
             path: normalizedRepoPath,
             alias: answers.repoAlias,
             workspaceKind: previewExecutionPlan.workspaceKind,
-            executionMode: previewExecutionPlan.resolvedDefaultMode,
+            executionMode: resolvedExecutionMode,
             reviewSystem
         },
         deliveryChannels: config.delivery.channels,
@@ -1187,6 +1309,10 @@ async function main() {
         process.exitCode = result.doctorQuick.summary === "blocked" ? 1 : 0;
         return;
     }
+    if (mapJiraCommand(command)) {
+        process.exitCode = await forwardJiraCliCommand(command, commandArgs);
+        return;
+    }
     const parsedCommandArgs = parseArgs(commandArgs);
     if (command === "doctor" && parsedCommandArgs.quick === "true") {
         const result = await runQuickDoctor();
@@ -1205,7 +1331,7 @@ async function main() {
     }
     catch (error) {
         if (error?.code === "ENOENT") {
-            console.error(`Config file not found at ${resolveDefaultConfigPath()}. Run \`optimus setup\` first.`);
+            console.error("Configuration is missing. Run `optimus setup` first.");
             process.exitCode = 1;
             return;
         }