haitask 0.1.2 → 0.1.4

package/README.md

@@ -34,7 +34,7 @@ git clone https://github.com/HidayetHidayetov/haitask.git && cd haitask && npm i
    cd /path/to/your/repo
    haitask init
    ```
-   **Interactive setup:** you’ll be asked for Jira base URL, project key, issue type, AI provider (groq / deepseek / openai), allowed branches, and commit prefixes. A `.haitaskrc` file is created from your answers. You’ll then choose where to store API keys: **this project** (`.env` in the repo) or **global** (`~/.haitask/.env`, shared across projects). A template `.env` is created in the chosen place — add your own keys there (never commit real keys).
+   **Interactive setup:** you’ll be asked for Jira base URL, project key, issue type, transition-to status after create (e.g. Done, To Do), AI provider (groq / deepseek / openai), allowed branches, and commit prefixes. A `.haitaskrc` file is created from your answers. You’ll then choose where to store API keys: **this project** (`.env` in the repo) or **global** (`~/.haitask/.env`, shared across projects). A template `.env` is created in the chosen place — add your own keys there (never commit real keys).
 
 2. **Add your API keys**  
    Edit the `.env` that was created (project or `~/.haitask/.env`): set one AI key (`GROQ_API_KEY`, `DEEPSEEK_API_KEY`, or `OPENAI_API_KEY`) and Jira keys (`JIRA_BASE_URL`, `JIRA_EMAIL`, `JIRA_API_TOKEN`). Optional: `JIRA_ACCOUNT_ID` to auto-assign issues.
@@ -56,12 +56,14 @@ git clone https://github.com/HidayetHidayetov/haitask.git && cd haitask && npm i
 | `haitask init` | Interactive setup: prompts for Jira/AI/rules → writes `.haitaskrc`, optional `.env` (project or ~/.haitask/.env). |
 | `haitask run` | Run pipeline: Git → AI → Jira (create issue). |
 | `haitask run --dry` | Same as above but skips the Jira API call. |
+| `haitask run --type <type>` | Same as `run` but use this Jira issue type (e.g. `Task`, `Bug`, `Story`, `Sub-task`). Overrides `jira.issueType` in `.haitaskrc` for this run only. |
+| `haitask run --status <status>` | Same as `run` but transition the issue to this status after create (e.g. `Done`, `To Do`, `In Progress`). Overrides `jira.transitionToStatus` in `.haitaskrc` for this run only. |
 
 ---
 
 ## Configuration
 
-- **`.haitaskrc`** (project root): Jira `baseUrl`, `projectKey`, `issueType`; AI `provider` and `model`; `rules.allowedBranches` and `rules.commitPrefixes`. Single source of truth for behaviour.
+- **`.haitaskrc`** (project root): Jira `baseUrl`, `projectKey`, `issueType`, `transitionToStatus`; AI `provider` and `model`; `rules.allowedBranches` and `rules.commitPrefixes`. Single source of truth for behaviour. **Issue type:** Default is `jira.issueType` (set at `haitask init` or edit `.haitaskrc`). Override for a single run with `haitask run --type Bug` (or `Story`, `Sub-task`, etc.). **Status after create:** Default is `jira.transitionToStatus` (e.g. `Done`). Override for a single run with `haitask run --status "To Do"` or `--status "In Progress"`.
 - **`.env`**: API keys only. Loaded in order: **project** `.env` (current directory), then **global** `~/.haitask/.env`. So you can use one global `.env` for all projects or override per repo.
 
 **AI providers** (set `ai.provider` in `.haitaskrc`): `groq` (default, free), `deepseek` (free), `openai` (paid). Set the corresponding key in `.env`.
@@ -81,3 +83,10 @@ git clone https://github.com/HidayetHidayetov/haitask.git && cd haitask && npm i
 - **CI / scripts:** Run `npx haitask run` (or `haitask run` if installed) from the repo root; ensure `.haitaskrc` and env vars are available in that environment.
 
 No framework-specific setup (e.g. Laravel, React, etc.); the tool only depends on Git and the config files above.
+
+---
+
+## Troubleshooting
+
+**Assignee not set / still unassigned**  
+In Jira Cloud, the user in `JIRA_ACCOUNT_ID` must be an **Assignable user** in that project, or the assign API will not apply (or will succeed but leave the issue unassigned). Fix: **Project → Space settings → People** — add yourself to the project (team-managed). For company-managed projects, ensure the permission scheme grants you **Assignable user**. You can still assign the issue to yourself manually in Jira; the API can only assign to users who are assignable in the project.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haitask",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Hidayet AI Task — Generate Jira tasks from Git commits using AI",
   "type": "module",
   "main": "src/index.js",

package/src/ai/utils.js

@@ -10,16 +10,23 @@
 export function buildPrompt(commitData) {
   const { message, branch, repoName } = commitData;
   const system = `You generate a Jira task from a Git commit. Reply with a single JSON object only, no markdown or extra text.
-Keys: "title" (short Jira task title, plain language — do NOT include prefixes like feat:, fix:, chore: in the title), "description" (detailed description, string), "labels" (array of strings, e.g. ["auto", "commit"]).`;
+
+Keys:
+- "title": Short, formal Jira task summary (professional wording). Do NOT copy the commit message verbatim. Rewrite as a clear, formal task title suitable for Jira (e.g. "Add user login validation" not "test login stuff"). Do NOT include prefixes like feat:, fix:, chore: in the title.
+- "description": Detailed description in plain language, suitable for Jira. Expand and formalize the intent of the commit; do not just paste the commit message.
+- "labels": Array of strings, e.g. ["auto", "commit"].
+- "priority": One of: "Highest", "High", "Medium", "Low", "Lowest". Infer from commit message (e.g. "urgent", "critical", "hotfix" → High; "minor", "tweak" → Low; unclear → "Medium"). Default to "Medium" if unsure.`;
   const user = `Repo: ${repoName}\nBranch: ${branch}\nCommit message:\n${message}\n\nGenerate the JSON object.`;
   return { system, user };
 }
 
+const VALID_PRIORITIES = ['Highest', 'High', 'Medium', 'Low', 'Lowest'];
+
 /**
- * Parse and validate AI response. Expects { title, description, labels }.
+ * Parse and validate AI response. Expects { title, description, labels, priority? }.
  * @param {string} raw
- * @returns {{ title: string, description: string, labels: string[] }}
- * @throws {Error} If invalid JSON or missing/ wrong types
+ * @returns {{ title: string, description: string, labels: string[], priority: string }}
+ * @throws {Error} If invalid JSON or missing/wrong types
  */
 export function parseTaskPayload(raw) {
   let obj;
@@ -35,8 +42,9 @@ export function parseTaskPayload(raw) {
     throw new Error('AI response labels must be an array of strings.');
   }
   const labels = obj.labels.filter((l) => typeof l === 'string');
-  // Strip conventional commit prefix from title so Jira gets a plain task title
   const rawTitle = (obj.title || '').trim();
   const title = rawTitle.replace(/^(feat|fix|chore|docs|style|refactor|test|build|ci):\s*/i, '').trim() || rawTitle;
-  return { title, description: obj.description.trim(), labels };
+  const rawPriority = (obj.priority || 'Medium').trim();
+  const priority = VALID_PRIORITIES.includes(rawPriority) ? rawPriority : 'Medium';
+  return { title, description: obj.description.trim(), labels, priority };
 }

package/src/commands/init.js

@@ -48,6 +48,7 @@ export async function runInit() {
     const jiraBaseUrl = await question(rl, 'Jira base URL', 'https://your-domain.atlassian.net');
     const jiraProjectKey = await question(rl, 'Jira project key', 'PROJ');
     const jiraIssueType = await question(rl, 'Jira issue type', 'Task');
+    const jiraTransitionToStatus = await question(rl, 'Transition issue to status after create (e.g. Done, To Do, In Progress)', 'Done');
     const aiProvider = await question(rl, 'AI provider (groq | deepseek | openai)', 'groq');
     const allowedBranchesStr = await question(rl, 'Allowed branches (comma-separated)', 'main,develop,master');
     const commitPrefixesStr = await question(rl, 'Commit prefixes (comma-separated)', 'feat,fix,chore');
@@ -57,7 +58,12 @@ export async function runInit() {
     const model = DEFAULT_MODELS[aiProvider.toLowerCase()] || DEFAULT_MODELS.groq;
 
     const config = {
-      jira: { baseUrl: jiraBaseUrl, projectKey: jiraProjectKey, issueType: jiraIssueType },
+      jira: {
+        baseUrl: jiraBaseUrl,
+        projectKey: jiraProjectKey,
+        issueType: jiraIssueType,
+        transitionToStatus: (jiraTransitionToStatus || 'Done').trim() || 'Done',
+      },
       ai: { provider: aiProvider.toLowerCase(), model },
       rules: { allowedBranches, commitPrefixes },
     };

package/src/commands/run.js

@@ -8,6 +8,8 @@ import { runPipeline } from '../core/pipeline.js';
 
 export async function runRun(options = {}) {
   const dry = options.dry ?? false;
+  const type = options.type?.trim() || undefined;
+  const status = options.status?.trim() || undefined;
 
   let config;
   try {
@@ -19,7 +21,7 @@ export async function runRun(options = {}) {
   }
 
   try {
-    const result = await runPipeline(config, { dry });
+    const result = await runPipeline(config, { dry, issueType: type, transitionToStatus: status });
 
     if (!result.ok) {
       console.error(result.error || 'Pipeline failed.');

package/src/config/init.js

@@ -11,6 +11,7 @@ const DEFAULT_RC = {
     baseUrl: 'https://your-domain.atlassian.net',
     projectKey: 'PROJ',
     issueType: 'Task',
+    transitionToStatus: 'Done',
   },
   ai: {
     provider: 'groq',

package/src/core/pipeline.js

@@ -44,11 +44,11 @@ function validateRules(commitData, config) {
 /**
  * Run full pipeline: Git → validate → AI → Jira (unless dry).
  * @param {object} config - Loaded .haitaskrc
- * @param {{ dry?: boolean }} options - dry: skip Jira API call
+ * @param {{ dry?: boolean, issueType?: string, transitionToStatus?: string }} options
  * @returns {Promise<{ ok: boolean, dry?: boolean, key?: string, payload?: object, commitData?: object, error?: string }>}
  */
 export async function runPipeline(config, options = {}) {
-  const { dry = false } = options;
+  const { dry = false, issueType: typeOverride, transitionToStatus: statusOverride } = options;
 
   const commitData = await getLatestCommitData();
   validateRules(commitData, config);
@@ -59,6 +59,17 @@ export async function runPipeline(config, options = {}) {
     return { ok: true, dry: true, payload, commitData };
   }
 
-  const { key } = await createIssue(payload, config);
+  let jiraConfig = config;
+  if (typeOverride != null || statusOverride != null) {
+    jiraConfig = {
+      ...config,
+      jira: {
+        ...config.jira,
+        ...(typeOverride != null && { issueType: typeOverride }),
+        ...(statusOverride != null && { transitionToStatus: statusOverride }),
+      },
+    };
+  }
+  const { key } = await createIssue(payload, jiraConfig);
   return { ok: true, key, payload, commitData };
 }

package/src/index.js

@@ -9,7 +9,7 @@ import { runRun } from './commands/run.js';
 program
   .name('haitask')
   .description('HAITASK — Generate Jira tasks from Git commits using AI')
-  .version('0.1.1');
+  .version('0.1.3');
 
 program
   .command('init')
@@ -20,6 +20,8 @@ program
   .command('run')
   .description('Run full pipeline: Git → AI → Jira')
   .option('--dry', 'Skip Jira API call, run everything else')
+  .option('-t, --type <type>', 'Jira issue type for this run (e.g. Task, Bug, Story, Sub-task). Overrides .haitaskrc jira.issueType')
+  .option('-s, --status <status>', 'Transition issue to this status after create (e.g. Done, "To Do", "In Progress"). Overrides .haitaskrc jira.transitionToStatus')
   .action((opts) => runRun(opts));
 
 program.parse();

package/src/jira/client.js

@@ -1,11 +1,8 @@
 /**
- * Jira REST client: create issue + assign.
- * Jira Cloud REST API v3. Assignee via dedicated endpoint or issue PUT.
+ * Jira REST client: create issue, assign, optional transition to status.
+ * Jira Cloud REST API v3.
  */
 
-/**
- * Convert plain text to Atlassian Document Format (ADF) for description field.
- */
 function plainTextToAdf(text) {
   const paragraphs = (text || '').trim().split(/\n+/).filter(Boolean);
   const content = paragraphs.length
@@ -14,71 +11,139 @@ function plainTextToAdf(text) {
   return { type: 'doc', version: 1, content };
 }
 
-/**
- * Assign issue to user. Tries two methods for compatibility.
- * 1) PUT /rest/api/3/issue/{key}/assignee  body: { accountId }
- * 2) PUT /rest/api/3/issue/{key}           body: { fields: { assignee: { accountId } } }
- * If accountId looks like "number:uuid", also tries uuid-only (some instances expect that).
- * @returns {{ ok: boolean, message?: string }}
- */
+const ASSIGNABLE_HINT =
+  'In Jira Cloud the assignee must be an "Assignable user" in the project: Project → Space settings → People.';
+
+function getAssigneeAccountId(config) {
+  const fromConfig = (config?.jira?.assigneeAccountId || '').trim();
+  if (fromConfig) return fromConfig;
+  return (process.env.JIRA_ACCOUNT_ID || '').trim();
+}
+
+async function getMyselfAccountId(baseUrl, auth) {
+  const res = await fetch(`${baseUrl}/rest/api/3/myself`, {
+    headers: { Accept: 'application/json', Authorization: `Basic ${auth}` },
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Jira myself API ${res.status}: ${text || res.statusText}`);
+  }
+  const data = await res.json();
+  const id = data?.accountId;
+  if (!id) throw new Error('Jira myself response missing accountId.');
+  return id;
+}
+
+async function verifyAssignee(baseUrl, issueKey, auth) {
+  try {
+    const res = await fetch(
+      `${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}?fields=assignee`,
+      { headers: { Accept: 'application/json', Authorization: `Basic ${auth}` } }
+    );
+    if (!res.ok) return false;
+    const data = await res.json();
+    return !!data?.fields?.assignee?.accountId;
+  } catch {
+    return false;
+  }
+}
+
 async function assignIssue(baseUrl, issueKey, accountId, auth) {
+  const id = (accountId || '').trim();
+  if (!id) {
+    return { ok: false, message: 'No assignee accountId. Set JIRA_ACCOUNT_ID in .env (full format: "712020:uuid").' };
+  }
+
   const headers = {
     'Content-Type': 'application/json',
     Accept: 'application/json',
     Authorization: `Basic ${auth}`,
   };
 
-  const candidates = [accountId];
-  if (accountId.includes(':')) {
-    candidates.push(accountId.split(':').slice(-1)[0]);
+  const assignUrl = `${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}/assignee`;
+  let res = await fetch(assignUrl, {
+    method: 'PUT',
+    headers,
+    body: JSON.stringify({ accountId: id }),
+  });
+
+  if (res.ok) {
+    const verified = await verifyAssignee(baseUrl, issueKey, auth);
+    if (verified) return { ok: true };
+    return { ok: false, message: `Assign API returned success but issue is still unassigned. ${ASSIGNABLE_HINT}` };
   }
 
-  let lastError = '';
-  for (const id of candidates) {
-    if (!id?.trim()) continue;
+  const body1 = await res.text();
+  let lastError = `assignee endpoint ${res.status}: ${body1 || res.statusText}`;
 
-    const assignUrl = `${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}/assignee`;
-    let res = await fetch(assignUrl, {
+  if (res.status === 400 || res.status === 404) {
+    res = await fetch(`${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}`, {
       method: 'PUT',
       headers,
-      body: JSON.stringify({ accountId: id }),
+      body: JSON.stringify({ fields: { assignee: { accountId: id } } }),
     });
-    if (res.ok) return { ok: true };
-    const body1 = await res.text();
-    lastError = `assignee endpoint ${res.status}: ${body1 || res.statusText}`;
-
-    if (res.status === 400 || res.status === 404) {
-      const issueUrl = `${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}`;
-      res = await fetch(issueUrl, {
-        method: 'PUT',
-        headers,
-        body: JSON.stringify({ fields: { assignee: { accountId: id } } }),
-      });
-      if (res.ok) return { ok: true };
-      const body2 = await res.text();
-      lastError = `assignee endpoint: ${body1}; issue PUT ${res.status}: ${body2 || res.statusText}`;
+    if (res.ok) {
+      const verified = await verifyAssignee(baseUrl, issueKey, auth);
+      if (verified) return { ok: true };
+      return { ok: false, message: `Assign API returned success but issue is still unassigned. ${ASSIGNABLE_HINT}` };
     }
+    const body2 = await res.text();
+    lastError += `; issue PUT ${res.status}: ${body2 || res.statusText}`;
   }
 
   return {
     ok: false,
-    message: `Assign failed. ${lastError} Use JIRA_ACCOUNT_ID from Jira: Profile → Account ID, or admin.atlassian.com → Directory → Users → user → ID in URL. In .env use quotes if value has colon: JIRA_ACCOUNT_ID="...".`,
+    message: `Assign failed. ${lastError} ${ASSIGNABLE_HINT} Use JIRA_ACCOUNT_ID (full format with colon) in .env.`,
   };
 }
 
 /**
- * Read assignee accountId: config first, then .env.
- * .env: use quotes if value contains colon, e.g. JIRA_ACCOUNT_ID="712020:ffdf70f7-..."
+ * Transition issue to the given status (e.g. Done, To Do, In Progress).
+ * Finds transition by destination status name (case-insensitive). No-op if status empty or not found.
  */
-function getAssigneeAccountId(config) {
-  const fromConfig = (config?.jira?.assigneeAccountId || '').trim();
-  if (fromConfig) return fromConfig;
-  const fromEnv = (process.env.JIRA_ACCOUNT_ID || '').trim();
-  return fromEnv;
+async function transitionToStatus(baseUrl, issueKey, auth, statusName) {
+  const name = (statusName || '').trim();
+  if (!name) return;
+
+  const headers = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    Authorization: `Basic ${auth}`,
+  };
+  const transRes = await fetch(
+    `${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}/transitions`,
+    { headers: { Accept: 'application/json', Authorization: `Basic ${auth}` } }
+  );
+  if (!transRes.ok) return;
+  const transData = await transRes.json();
+  const transitions = transData?.transitions || [];
+  const target = name.toLowerCase();
+  const transition = transitions.find(
+    (t) => (t.to?.name || '').toLowerCase() === target || (t.name || '').toLowerCase() === target
+  );
+  if (!transition?.id) return;
+  await fetch(`${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}/transitions`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ transition: { id: transition.id } }),
+  });
+}
+
+const VALID_PRIORITIES = ['Highest', 'High', 'Medium', 'Low', 'Lowest'];
+
+function normalizePriority(value) {
+  const v = (value || '').trim();
+  if (!v) return 'Medium';
+  const cap = v.charAt(0).toUpperCase() + v.slice(1).toLowerCase();
+  if (VALID_PRIORITIES.includes(cap)) return cap;
+  if (['High', 'Medium', 'Low'].includes(cap)) return cap;
+  return 'Medium';
 }
 
 /**
- * Create a Jira issue and optionally assign to JIRA_ACCOUNT_ID.
+ * Create a Jira issue, assign, and optionally transition to a status.
+ * @param {object} payload - { title, description, labels, priority }
+ * @param {object} config - .haitaskrc (jira.baseUrl, projectKey, issueType, transitionToStatus)
  */
 export async function createIssue(payload, config) {
   const baseUrl = (config?.jira?.baseUrl || process.env.JIRA_BASE_URL || '').replace(/\/$/, '');
@@ -91,38 +156,67 @@ export async function createIssue(payload, config) {
 
   const projectKey = config?.jira?.projectKey || 'PROJ';
   const issueType = config?.jira?.issueType || 'Task';
-  const assigneeAccountId = getAssigneeAccountId(config);
+  const rawStatus = config?.jira?.transitionToStatus;
+  const transitionToStatusName = rawStatus === undefined || rawStatus === null ? 'Done' : String(rawStatus).trim();
+  const auth = Buffer.from(`${email}:${token}`, 'utf-8').toString('base64');
+
+  let assigneeAccountId = getAssigneeAccountId(config);
+  if (!assigneeAccountId) {
+    assigneeAccountId = await getMyselfAccountId(baseUrl, auth);
+  } else if (!assigneeAccountId.includes(':')) {
+    assigneeAccountId = await getMyselfAccountId(baseUrl, auth);
+  }
+
+  const priorityName = normalizePriority(payload.priority);
 
-  const fields = {
+  const baseFields = {
     project: { key: projectKey },
     summary: (payload.title || '').trim() || 'Untitled',
     description: plainTextToAdf(payload.description || ''),
     issuetype: { name: issueType },
     labels: Array.isArray(payload.labels) ? payload.labels.filter((l) => typeof l === 'string') : [],
+    assignee: { accountId: assigneeAccountId },
   };
 
-  const auth = Buffer.from(`${email}:${token}`, 'utf-8').toString('base64');
-  const createRes = await fetch(`${baseUrl}/rest/api/3/issue`, {
+  let fields = { ...baseFields, priority: { name: priorityName } };
+  let createRes = await fetch(`${baseUrl}/rest/api/3/issue`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json', Accept: 'application/json', Authorization: `Basic ${auth}` },
     body: JSON.stringify({ fields }),
   });
 
   if (!createRes.ok) {
-    const text = await createRes.text();
-    throw new Error(`Jira API error ${createRes.status}: ${text || createRes.statusText}`);
+    const firstErrorText = await createRes.text();
+    if (createRes.status === 400) {
+      const isPriority = /priority|Priority/i.test(firstErrorText);
+      const isAssignee = /assignee|Assignee/i.test(firstErrorText);
+      const retryFields = { ...baseFields };
+      if (isAssignee) delete retryFields.assignee;
+      if (isPriority) delete retryFields.priority;
+      if (isPriority || isAssignee) {
+        createRes = await fetch(`${baseUrl}/rest/api/3/issue`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', Accept: 'application/json', Authorization: `Basic ${auth}` },
+          body: JSON.stringify({ fields: retryFields }),
+        });
+      }
+    }
+    if (!createRes.ok) {
+      const errText = createRes.bodyUsed ? firstErrorText : await createRes.text();
+      throw new Error(`Jira API error ${createRes.status}: ${errText || createRes.statusText}`);
+    }
   }
 
   const data = await createRes.json();
   const key = data?.key;
   if (!key) throw new Error('Jira API response missing issue key.');
 
-  if (assigneeAccountId) {
-    const assignResult = await assignIssue(baseUrl, key, assigneeAccountId, auth);
-    if (!assignResult.ok) {
-      throw new Error(`Issue ${key} created but assign failed. ${assignResult.message || ''}`);
-    }
+  const assignResult = await assignIssue(baseUrl, key, assigneeAccountId, auth);
+  if (!assignResult.ok) {
+    throw new Error(`Issue ${key} created but assign failed. ${assignResult.message || ''}`);
   }
 
+  await transitionToStatus(baseUrl, key, auth, transitionToStatusName);
+
   return { key, self: data.self };
 }