@jive-ai/cli 0.0.46 → 0.0.48

package/dist/index.mjs

@@ -774,6 +774,7 @@ const queries = {
         gitBranch
         previewUrl
         autoApprove
+        linkedIssueNumber
         project {
           id
           name
@@ -1072,6 +1073,22 @@ const mutations = {
         }
       }
     }
+  `),
+	CommentCreate: graphql(`
+    mutation CommentCreate($input: CreateCommentInput!) {
+      commentCreate(input: $input) {
+        success
+        comment {
+          id
+          body
+          htmlUrl
+        }
+        errors {
+          message
+          code
+        }
+      }
+    }
   `),
 	RegisterRunner: graphql(`
     mutation RegisterRunner($input: RegisterRunnerInput!) {
@@ -1539,7 +1556,8 @@ var ApiClient = class {
 				description: data.task.description || "",
 				status: data.task.status.toLowerCase().replace("_", "-"),
 				gitBranch: data.task.gitBranch || "",
-				previewUrl: data.task.previewUrl || void 0
+				previewUrl: data.task.previewUrl || void 0,
+				linkedIssueNumber: data.task.linkedIssueNumber ?? null
 			},
 			plan: data.task.currentPlan ? {
 				id: parseInt(data.task.currentPlan.id, 10),
@@ -1652,6 +1670,22 @@ var ApiClient = class {
 			}
 		};
 	}
+	async createComment(projectId, data) {
+		const result = await (await getGraphQLClient()).request(mutations.CommentCreate, { input: {
+			projectId: String(projectId),
+			issueNumber: data.issueNumber,
+			content: data.content
+		} });
+		if (result.commentCreate.errors?.length) throw this.formatError({ message: result.commentCreate.errors[0].message });
+		return {
+			success: result.commentCreate.success,
+			comment: {
+				id: result.commentCreate.comment.id,
+				body: result.commentCreate.comment.body,
+				htmlUrl: result.commentCreate.comment.htmlUrl
+			}
+		};
+	}
 	async getTaskSteps(id) {
 		const data = await (await getGraphQLClient()).request(queries.GetPlan, { id: String(id) });
 		if (!data.plan?.steps) return [];
@@ -2050,7 +2084,7 @@ async function createGraphQLClient() {
 
 //#endregion
 //#region package.json
-var version = "0.0.46";
+var version = "0.0.48";
 
 //#endregion
 //#region src/runner/index.ts
@@ -2210,37 +2244,41 @@ var TaskRunner = class {
 		}
 	}
 	async fetchTaskProcess(taskId) {
-		const existingProcess = this.taskProcesses[taskId.toString()];
-		if (existingProcess) return existingProcess;
+		const key = taskId.toString();
+		const existing = this.taskProcesses[key];
+		if (existing) return existing;
 		if (Object.values(this.taskProcesses).filter((p) => p !== null).length >= this.maxConcurrentTasks) {
 			console.warn(chalk.yellow(`Maximum concurrent tasks reached (${this.maxConcurrentTasks})`));
 			return null;
 		}
+		const initPromise = this.initTaskProcess(taskId);
+		this.taskProcesses[key] = initPromise;
+		const result = await initPromise;
+		if (!result && this.taskProcesses[key] === initPromise) this.taskProcesses[key] = null;
+		return result;
+	}
+	async initTaskProcess(taskId) {
 		const ctx = await this.fetchTaskContext(taskId);
 		if (!ctx) {
 			console.error(chalk.red(`Failed to fetch context for task ${taskId}`));
 			return null;
 		}
-		return this.taskProcesses[taskId.toString()] = new Promise((resolve) => {
-			(this.config.type === "docker" ? spawnTaskDocker(ctx, this.config, {
+		return {
+			process: this.config.type === "docker" ? await spawnTaskDocker(ctx, this.config, {
 				onMessage: (message) => this.onTaskMessage(ctx.taskId, message),
 				onError: () => {},
 				onClose: () => {
 					this.taskProcesses[ctx.taskId.toString()] = null;
 				}
-			}) : Promise.resolve(spawnTask(ctx, {
+			}) : spawnTask(ctx, {
 				onMessage: (message) => this.onTaskMessage(ctx.taskId, message),
 				onError: () => {},
 				onClose: () => {
 					this.taskProcesses[ctx.taskId.toString()] = null;
 				}
-			}))).then((process$1) => {
-				resolve({
-					process: process$1,
-					ctx
-				});
-			});
-		});
+			}),
+			ctx
+		};
 	}
 	async sendToTask(taskId, message) {
 		const result = await this.fetchTaskProcess(taskId);
@@ -2435,7 +2473,13 @@ var TaskRunner = class {
       `);
 			const pendingTasks = (await client.request(query$1, { limit: availableSlots })).tasks.edges.map((e$2) => e$2.node);
 			if (pendingTasks.length > 0) console.log(chalk.yellow(`Found ${pendingTasks.length} pending task(s) to pick up`));
-			for (const task of pendingTasks) await this.pickupPendingTask(parseInt(task.id));
+			for (const task of pendingTasks) {
+				if (this.taskProcesses[task.id]) {
+					console.log(chalk.dim(`Task ${task.id} already managed, skipping`));
+					continue;
+				}
+				await this.pickupPendingTask(parseInt(task.id));
+			}
 		} catch (error$1) {
 			if (!error$1.message?.includes("Unable to connect")) console.error(chalk.red(`Failed to poll for pending tasks: ${error$1.message}`));
 		}
@@ -2507,17 +2551,10 @@ async function queryClaude(prompt, mcpServer, opts) {
 			permissionMode: mapPermissionMode(permissionMode),
 			...betaFlags.length > 0 && { betas: betaFlags },
 			canUseTool: async (toolName, input) => {
-				if (toolName === "AskUserQuestion") {
-					const result = await task.requestUserQuestions(input);
-					if (result) return {
-						behavior: "allow",
-						updatedInput: result
-					};
-					else return {
-						behavior: "deny",
-						message: "User did not answer questions in time"
-					};
-				}
+				if (toolName === "AskUserQuestion") return {
+					behavior: "deny",
+					message: "AskUserQuestion is not allowed. Use the ask_user_question tool from the jive-tasks MCP server instead."
+				};
 				if (await task.requestToolPermission(toolName, input)) return {
 					behavior: "allow",
 					updatedInput: input
@@ -2527,6 +2564,11 @@ async function queryClaude(prompt, mcpServer, opts) {
 					message: "User denied this action"
 				};
 			},
+			systemPrompt: {
+				type: "preset",
+				preset: "claude_code",
+				append: "When you want to use AskUserQuestion, use the ask_user_question tool from the jive-tasks MCP server instead. DO NOT USE THE AskUserQuestion tool directly."
+			},
 			stderr: (data) => {
 				console.error(data.toString());
 			}
@@ -2738,8 +2780,13 @@ function createTasksSdkServer(task) {
 
         If the next step contains a subagent, you must invoke the subagent for the next step.
 
-        If result contains \`isComplete: true\`, then the task is complete and you MUST create a pull request using the \`create_pull_request\` tool.
-        The user is expecting pull requests to be automatically created when the task is complete.
+        If result contains \`isComplete: true\`, then the task is complete and you MUST add an issue comment using the \`add_issue_comment\` tool.
+        The comment MUST include: 
+        - A very concise (1-2 sentence) description of the changes
+        - A reference to the branch: ${task.branch}
+        - A link to the task: https://getjive.app/app/tasks/${task.id}
+
+        The user is expecting issue comments to be automatically created when the task is complete.
         `, {
 				stepId: z.number(),
 				commitMessage: z.string().describe("Concise commit message describing changes"),
@@ -2803,6 +2850,51 @@ function createTasksSdkServer(task) {
 					};
 				}
 			}),
+			tool("add_issue_comment", "Add a comment to the linked issue on GitHub or GitLab. Use this to post updates, summaries, or task completion notices on the issue.", { content: z.string().describe("The comment body to post on the issue (supports markdown)") }, async (args) => {
+				if (!context) return {
+					content: [{
+						type: "text",
+						text: "Error: Task context not initialized"
+					}],
+					isError: true
+				};
+				try {
+					const apiClient$1 = getApiClient();
+					const { task: taskData, project } = await apiClient$1.getTask(context.taskId);
+					if (!project) return {
+						content: [{
+							type: "text",
+							text: "Error: Project not found for this task"
+						}],
+						isError: true
+					};
+					if (!taskData.linkedIssueNumber) return {
+						content: [{
+							type: "text",
+							text: "Error: No linked issue found for this task. Cannot add comment."
+						}],
+						isError: true
+					};
+					task.debugLog(`Adding comment to issue #${taskData.linkedIssueNumber}`);
+					const result = await apiClient$1.createComment(project.id, {
+						issueNumber: taskData.linkedIssueNumber,
+						content: args.content
+					});
+					task.debugLog(`Comment created: ${JSON.stringify(result, null, 2)}`);
+					return { content: [{
+						type: "text",
+						text: `Comment posted successfully on issue #${taskData.linkedIssueNumber}!\n\nURL: ${result.comment.htmlUrl}`
+					}] };
+				} catch (error$1) {
+					return {
+						content: [{
+							type: "text",
+							text: `Error adding issue comment: ${error$1.message}`
+						}],
+						isError: true
+					};
+				}
+			}),
 			tool("create_issue", "Create an issue on GitHub or GitLab for the current project. Use this to track bugs, feature requests, or other work items.", {
 				title: z.string().describe("Issue title - a concise summary of the issue"),
 				body: z.string().describe("Issue body/description - detailed explanation of the issue"),
@@ -2900,6 +2992,38 @@ function createTasksSdkServer(task) {
 						isError: true
 					};
 				}
+			}),
+			tool("ask_user_question", "USE THIS INSTEAD OF AskUserQuestion. Ask the user clarifying questions. Returns immediately - answers will be provided in a follow-up message.", { questions: z.array(z.object({
+				question: z.string().describe("The question to ask"),
+				header: z.string().describe("Short header/label for the question"),
+				options: z.array(z.object({
+					label: z.string(),
+					description: z.string()
+				})).describe("Options for the user to choose from"),
+				multiSelect: z.boolean().describe("Allow multiple selections")
+			})).describe("Questions to ask the user") }, async (args) => {
+				if (!context) return {
+					content: [{
+						type: "text",
+						text: "Error: Task context not initialized"
+					}],
+					isError: true
+				};
+				try {
+					task.sendUserQuestionRequest(args.questions);
+					return { content: [{
+						type: "text",
+						text: `Questions sent to user. Their answers will be provided in a follow-up message. You may continue with other work while waiting.`
+					}] };
+				} catch (error$1) {
+					return {
+						content: [{
+							type: "text",
+							text: `Error: ${error$1.message}`
+						}],
+						isError: true
+					};
+				}
 			})
 		]
 	});
@@ -3068,7 +3192,6 @@ var Task = class {
 	heartbeatInterval = null;
 	pendingAcks = /* @__PURE__ */ new Map();
 	pendingPermissions = /* @__PURE__ */ new Map();
-	pendingQuestions = /* @__PURE__ */ new Map();
 	tunnels = /* @__PURE__ */ new Map();
 	proxies = /* @__PURE__ */ new Map();
 	primaryTunnelHost = null;
@@ -3088,6 +3211,9 @@ var Task = class {
 		}
 		return tasksConfig.git.default_branch;
 	}
+	get branch() {
+		return this.ctx.branch;
+	}
 	get projectId() {
 		return this.ctx.projectId;
 	}
@@ -3243,10 +3369,6 @@ var Task = class {
 						this.handleToolPermissionResponse(inputMessage.payload);
 						continue;
 					}
-					if (inputMessage.type === "user_question_response") {
-						this.handleUserQuestionResponse(inputMessage.payload);
-						continue;
-					}
 					if (this.status !== "idle") {
 						this.debugLog(`Queueing message (status: ${this.status}): ${inputMessage.type}`);
 						this.queuedMessages.push(inputMessage);
@@ -3301,43 +3423,21 @@ var Task = class {
 		return approved;
 	}
 	/**
-	* Request user to answer questions. Returns promise that resolves to { questions, answers } or null.
-	* Auto-denies (returns null) after 60 seconds if no response received.
+	* Send user questions to the server (non-blocking).
+	* Answers will come back as a user message via promptSendToRunner.
 	*/
-	async requestUserQuestions(input) {
+	sendUserQuestionRequest(questions) {
 		const requestId = crypto.randomUUID();
-		const TIMEOUT_MS = 6e4 * 60 * 24;
-		const questionPromise = new Promise((resolve) => {
-			const timeout = setTimeout(() => {
-				this.debugLog(`User question request ${requestId} timed out (24h)`);
-				this.pendingQuestions.delete(requestId);
-				resolve(null);
-			}, TIMEOUT_MS);
-			this.pendingQuestions.set(requestId, {
-				resolve,
-				timeout
-			});
-		});
 		this.sendToTaskRunner({
 			type: "user_question_request",
 			payload: {
 				requestId,
 				sessionId: this.ctx.sessionId,
-				questions: input.questions,
-				expiresAt: new Date(Date.now() + TIMEOUT_MS).toISOString()
+				questions,
+				expiresAt: new Date(Date.now() + 6e4 * 60 * 24).toISOString()
 			}
 		});
-		this.debugLog(`Waiting for user to answer ${input.questions.length} question(s)...`);
-		const answers = await questionPromise;
-		if (!answers) {
-			this.debugLog(`User did not answer questions in time`);
-			return null;
-		}
-		this.debugLog(`User answered questions`);
-		return {
-			questions: input.questions,
-			answers
-		};
+		this.debugLog(`Sent ${questions.length} question(s) to user (requestId: ${requestId})`);
 	}
 	/**
 	* Handle tool permission response from runner
@@ -3353,20 +3453,6 @@ var Task = class {
 		pending.resolve(payload.approved);
 		this.pendingPermissions.delete(payload.requestId);
 	}
-	/**
-	* Handle user question response from runner
-	*/
-	handleUserQuestionResponse(payload) {
-		const pending = this.pendingQuestions.get(payload.requestId);
-		if (!pending) {
-			this.debugLog(`Received question response for unknown request: ${payload.requestId}`);
-			return;
-		}
-		this.updateLastActivity();
-		clearTimeout(pending.timeout);
-		pending.resolve(payload.answers);
-		this.pendingQuestions.delete(payload.requestId);
-	}
 	processMessage(inputMessage) {
 		this.updateLastActivity();
 		switch (inputMessage.type) {
@@ -3379,9 +3465,6 @@ var Task = class {
 			case "tool_permission_response":
 				this.handleToolPermissionResponse(inputMessage.payload);
 				break;
-			case "user_question_response":
-				this.handleUserQuestionResponse(inputMessage.payload);
-				break;
 		}
 	}
 	processQueuedMessages() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@jive-ai/cli",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "main": "index.js",
   "files": [
     "dist",
@@ -15,7 +15,7 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "typecheck": "tsc --noEmit",
     "build": "tsdown && npm pack && npm install -g jive-ai-cli-*.tgz",
-    "docker:clean": "docker rmi jiveai/task:latest jiveai/task:$npm_package_version",
+    "docker:clean": "docker rmi jiveai/task:latest jiveai/task:$npm_package_version || true",
     "docker:build": "bun run build && npm run docker:clean && .docker/build.sh",
     "docker:push": ".docker/build.sh --push",
     "prepublishOnly": "npm run typecheck && npm run build"