haitask 0.1.2 → 0.1.5

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.5",
   "description": "Hidayet AI Task — Generate Jira tasks from Git commits using AI",
   "type": "module",
   "main": "src/index.js",

package/src/ai/utils.js

@@ -2,6 +2,8 @@
  * Shared AI utilities: prompt building and response parsing.
  */
 
+const CONVENTIONAL_PREFIXES = /^(feat|fix|chore|docs|style|refactor|test|build|ci):\s*/i;
+
 /**
  * Build system + user prompt from commit data.
  * @param {{ message: string, branch: string, repoName: string }} commitData
@@ -10,16 +12,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 +44,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 title = rawTitle.replace(CONVENTIONAL_PREFIXES, '').trim() || rawTitle;
+  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 },
     };
@@ -91,19 +97,19 @@ export async function runInit() {
     rl.close();
   }
 
-  let config;
+  let loadedConfig = null;
   try {
-    config = loadConfig();
+    loadedConfig = loadConfig();
   } catch {
-    config = null;
+    // rc just written; load may fail if cwd changed
   }
 
-  const { valid, missing } = validateEnv(cwd, config);
+  const { valid, missing } = validateEnv(cwd, loadedConfig);
   if (!valid) {
     console.warn('\nAdd these to your .env before "haitask run":', missing.join(', '));
     console.log('Env is read from: project .env, then ~/.haitask/.env');
-    if (config?.ai?.provider === 'groq') console.log('Groq key: https://console.groq.com/keys');
-    if (config?.ai?.provider === 'deepseek') console.log('Deepseek key: https://platform.deepseek.com/');
+    if (loadedConfig?.ai?.provider === 'groq') console.log('Groq key: https://console.groq.com/keys');
+    if (loadedConfig?.ai?.provider === 'deepseek') console.log('Deepseek key: https://platform.deepseek.com/');
     process.exitCode = 1;
     return;
   }

package/src/commands/run.js

@@ -1,13 +1,20 @@
 /**
- * haitask run [--dry] — Execute full pipeline
+ * haitask run — Execute full pipeline (Git → AI → Jira).
  * Thin handler: load config, call pipeline, output result.
  */
 
 import { loadConfig } from '../config/load.js';
 import { runPipeline } from '../core/pipeline.js';
 
+function buildIssueUrl(config, issueKey) {
+  const baseUrl = (config?.jira?.baseUrl || process.env.JIRA_BASE_URL || '').replace(/\/$/, '');
+  return baseUrl ? `${baseUrl}/browse/${issueKey}` : issueKey;
+}
+
 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 +26,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.');
@@ -32,18 +39,15 @@ export async function runRun(options = {}) {
       console.log('Commit:', result.commitData?.message?.split('\n')[0] || '');
       console.log('Would create Jira task:', result.payload?.title || '');
       if (result.payload?.description) {
-        console.log('Description (preview):', result.payload.description.slice(0, 120) + (result.payload.description.length > 120 ? '...' : ''));
+        const desc = result.payload.description;
+        console.log('Description (preview):', desc.slice(0, 120) + (desc.length > 120 ? '...' : ''));
       }
       return;
     }
 
-    // Keep output URL consistent with Jira client behavior (prefer .haitaskrc baseUrl).
-    const baseUrl = (config?.jira?.baseUrl || process.env.JIRA_BASE_URL || '').replace(/\/$/, '');
-    const issueUrl = baseUrl ? `${baseUrl}/browse/${result.key}` : result.key;
     console.log('Created Jira issue:', result.key);
-    if (issueUrl !== result.key) {
-      console.log(issueUrl);
-    }
+    const issueUrl = buildIssueUrl(config, result.key);
+    if (issueUrl !== result.key) console.log(issueUrl);
   } catch (err) {
     console.error('Error:', err.message);
     process.exitCode = 1;

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',
@@ -28,14 +29,12 @@ const REQUIRED_ENV_KEYS = ['JIRA_BASE_URL', 'JIRA_EMAIL', 'JIRA_API_TOKEN'];
 /**
  * Create .haitaskrc in dir if it does not exist.
  * @param {string} [dir] - Directory (default: process.cwd())
- * @returns {{ created: boolean }} created true if file was written, false if already existed
+ * @returns {{ created: boolean }}
  */
 export function createDefaultConfigFile(dir = process.cwd()) {
-  const path = resolve(dir, '.haitaskrc');
-  if (existsSync(path)) {
-    return { created: false };
-  }
-  writeFileSync(path, JSON.stringify(DEFAULT_RC, null, 2), 'utf-8');
+  const rcPath = resolve(dir, '.haitaskrc');
+  if (existsSync(rcPath)) return { created: false };
+  writeFileSync(rcPath, JSON.stringify(DEFAULT_RC, null, 2), 'utf-8');
   return { created: true };
 }
 

package/src/config/load.js

@@ -6,36 +6,36 @@
 import { readFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 
-const DEFAULT_CONFIG_PATH = '.haitaskrc';
-
+const CONFIG_FILENAME = '.haitaskrc';
 const REQUIRED_KEYS = ['jira', 'ai', 'rules'];
 
 /**
+ * Load and validate .haitaskrc.
  * @param {string} [configPath] - Absolute or cwd-relative path to .haitaskrc
  * @returns {object} Parsed config
  * @throws {Error} If file missing, invalid JSON, or missing required sections
  */
 export function loadConfig(configPath) {
-  const path = configPath
+  const filePath = configPath
     ? resolve(configPath)
-    : resolve(process.cwd(), DEFAULT_CONFIG_PATH);
+    : resolve(process.cwd(), CONFIG_FILENAME);
 
-  if (!existsSync(path)) {
-    throw new Error(`Config not found: ${path}. Run "haitask init" first.`);
+  if (!existsSync(filePath)) {
+    throw new Error(`Config not found: ${filePath}. Run "haitask init" first.`);
   }
 
   let raw;
   try {
-    raw = readFileSync(path, 'utf-8');
+    raw = readFileSync(filePath, 'utf-8');
   } catch (err) {
-    throw new Error(`Cannot read config: ${path}. ${err.message}`);
+    throw new Error(`Cannot read config: ${filePath}. ${err.message}`);
   }
 
   let config;
   try {
     config = JSON.parse(raw);
   } catch (err) {
-    throw new Error(`Invalid JSON in ${path}. ${err.message}`);
+    throw new Error(`Invalid JSON in ${filePath}. ${err.message}`);
   }
 
   const missing = REQUIRED_KEYS.filter((key) => !config[key] || typeof config[key] !== 'object');

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,23 @@ export async function runPipeline(config, options = {}) {
     return { ok: true, dry: true, payload, commitData };
   }
 
-  const { key } = await createIssue(payload, config);
+  const jiraConfig = mergeJiraOverrides(config, { issueType: typeOverride, transitionToStatus: statusOverride });
+  const { key } = await createIssue(payload, jiraConfig);
   return { ok: true, key, payload, commitData };
 }
+
+/**
+ * Merge run-time overrides into config.jira. Returns config unchanged if no overrides.
+ */
+function mergeJiraOverrides(config, overrides) {
+  const { issueType, transitionToStatus } = overrides;
+  if (issueType == null && transitionToStatus == null) return config;
+  return {
+    ...config,
+    jira: {
+      ...config.jira,
+      ...(issueType != null && { issueType }),
+      ...(transitionToStatus != null && { transitionToStatus }),
+    },
+  };
+}

package/src/index.js

@@ -1,15 +1,20 @@
 #!/usr/bin/env node
 
+import { createRequire } from 'node:module';
 import { loadEnvFiles } from './config/env-loader.js';
-loadEnvFiles();
 import { program } from 'commander';
 import { runInit } from './commands/init.js';
 import { runRun } from './commands/run.js';
 
+loadEnvFiles();
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
 program
   .name('haitask')
   .description('HAITASK — Generate Jira tasks from Git commits using AI')
-  .version('0.1.1');
+  .version(pkg.version);
 
 program
   .command('init')
@@ -20,6 +25,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,25 @@
 /**
- * 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.
- */
+const ASSIGN_DELAY_MS = 4000;
+const DEFAULT_PROJECT_KEY = 'PROJ';
+const DEFAULT_ISSUE_TYPE = 'Task';
+const DEFAULT_TRANSITION_STATUS = 'Done';
+const VALID_PRIORITIES = ['Highest', 'High', 'Medium', 'Low', 'Lowest'];
+
+const ASSIGNABLE_HINT =
+  'In Jira Cloud the assignee must be an "Assignable user" in the project: Project → Space settings → People.';
+
+function jiraHeaders(auth) {
+  return {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    Authorization: `Basic ${auth}`,
+  };
+}
+
 function plainTextToAdf(text) {
   const paragraphs = (text || '').trim().split(/\n+/).filter(Boolean);
   const content = paragraphs.length
@@ -14,71 +28,125 @@ 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 }}
- */
+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 headers = {
-    'Content-Type': 'application/json',
-    Accept: 'application/json',
-    Authorization: `Basic ${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 = jiraHeaders(auth);
+  const assignUrl = `${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}/assignee`;
+  let res = await fetch(assignUrl, {
+    method: 'PUT',
+    headers,
+    body: JSON.stringify({ accountId: id }),
+  });
 
-  const candidates = [accountId];
-  if (accountId.includes(':')) {
-    candidates.push(accountId.split(':').slice(-1)[0]);
+  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 = jiraHeaders(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 } }),
+  });
+}
+
+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(/\/$/, '');
@@ -89,40 +157,72 @@ export async function createIssue(payload, config) {
     throw new Error('Jira credentials missing. Set JIRA_BASE_URL, JIRA_EMAIL, JIRA_API_TOKEN in .env.');
   }
 
-  const projectKey = config?.jira?.projectKey || 'PROJ';
-  const issueType = config?.jira?.issueType || 'Task';
-  const assigneeAccountId = getAssigneeAccountId(config);
+  const projectKey = config?.jira?.projectKey || DEFAULT_PROJECT_KEY;
+  const issueType = config?.jira?.issueType || DEFAULT_ISSUE_TYPE;
+  const rawStatus = config?.jira?.transitionToStatus;
+  const transitionToStatusName =
+    rawStatus === undefined || rawStatus === null ? DEFAULT_TRANSITION_STATUS : 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}` },
+    headers: jiraHeaders(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: jiraHeaders(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 || ''}`);
-    }
+  await new Promise((r) => setTimeout(r, ASSIGN_DELAY_MS));
+
+  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 };
 }

package/src/utils/index.js

@@ -1,5 +1,4 @@
 /**
- * Shared utilities (if any).
+ * Shared utilities. Add helpers here when used by multiple modules.
  */
-
-export function noop() { }
+export { };