haitask 0.1.0

package/.env.example

@@ -0,0 +1,18 @@
+# HAITASK — copy to .env and fill in
+# Set only the key for the provider you use in .haitaskrc (ai.provider)
+
+# Groq (FREE, fast): https://console.groq.com/keys
+GROQ_API_KEY=your-groq-api-key
+
+# Deepseek (FREE): https://platform.deepseek.com/
+DEEPSEEK_API_KEY=your-deepseek-api-key
+
+# OpenAI (paid): https://platform.openai.com/api-keys
+OPENAI_API_KEY=your-openai-api-key
+
+# Jira (required for creating issues)
+JIRA_BASE_URL=https://your-domain.atlassian.net
+JIRA_EMAIL=your@email.com
+JIRA_API_TOKEN=your-jira-api-token
+# Optional: assign new issues to you. Jira Cloud account ID: Profile → Account ID, or admin.atlassian.com → Directory → Users. If value contains ":", use quotes: JIRA_ACCOUNT_ID="id:uuid"
+JIRA_ACCOUNT_ID=your-account-id

package/README.md

@@ -0,0 +1,86 @@
+# HAITASK
+
+Generate Jira issues from your latest Git commit using AI. Reads commit message and branch, produces a structured task (title, description, labels) via an AI provider, and creates the issue in Jira. Framework- and language-agnostic: works with any Git repo.
+
+**Requirements:** Node.js >= 18
+
+---
+
+## Install
+
+```bash
+npm install -g haitask
+```
+
+Or run without installing:
+
+```bash
+npx haitask
+```
+
+From source (clone then link):
+
+```bash
+git clone https://github.com/HidayetHidayetov/haitask.git && cd haitask && npm install && npm link
+```
+
+---
+
+## Quick start
+
+1. **Credentials (one-time)**  
+   Create a `.env` (e.g. in your home dir or a shared config folder) with:
+   - One AI provider key: `GROQ_API_KEY`, `DEEPSEEK_API_KEY`, or `OPENAI_API_KEY`
+   - Jira: `JIRA_BASE_URL`, `JIRA_EMAIL`, `JIRA_API_TOKEN`  
+   Copy from `.env.example` in the repo.
+
+2. **Per project (one-time)**  
+   In the Git repo where you want to create Jira issues:
+   ```bash
+   cd /path/to/your/repo
+   haitask init
+   ```
+   This creates `.haitaskrc`. Edit it: set `jira.projectKey`, `jira.baseUrl`, and optionally `rules.allowedBranches` and `rules.commitPrefixes`.
+
+3. **Create a Jira issue from the latest commit**  
+   After committing:
+   ```bash
+   haitask run
+   ```
+   Pipeline: read latest commit → validate branch/prefix from `.haitaskrc` → call AI → create Jira issue.  
+   To test without creating an issue: `haitask run --dry`.
+
+---
+
+## Commands
+
+| Command | Description |
+|--------|-------------|
+| `haitask init` | Create `.haitaskrc` in cwd (no overwrite if present). Validates env. |
+| `haitask run` | Run pipeline: Git → AI → Jira (create issue). |
+| `haitask run --dry` | Same as above but skips the Jira API call. |
+
+---
+
+## Configuration
+
+- **`.haitaskrc`** (project root): Jira `baseUrl`, `projectKey`, `issueType`; AI `provider` and `model`; `rules.allowedBranches` and `rules.commitPrefixes`. Single source of truth for behaviour.
+- **`.env`**: API keys only. Prefer loading it from the directory where you run `haitask` (or the same folder as the cloned repo when using `npm link`).
+
+**AI providers** (set `ai.provider` in `.haitaskrc`): `groq` (default, free), `deepseek` (free), `openai` (paid). Set the corresponding key in `.env`.
+
+**Rules:** If `allowedBranches` is non-empty, the current branch must be in the list. If `commitPrefixes` is non-empty, the commit message must start with one of them (e.g. `feat:`, `fix:`). Adjust to match your workflow.
+
+**Jira assignee:** Optional. Set `JIRA_ACCOUNT_ID` in `.env` (Jira Cloud account ID). If the value contains a colon, use quotes: `JIRA_ACCOUNT_ID="id:uuid"`. The created issue will be assigned via a separate API call after create.
+
+**Task title:** The AI is instructed not to include commit-type prefixes (e.g. `feat:`) in the Jira title; the code also strips them from the AI output so the issue summary stays clean.
+
+---
+
+## Usage patterns
+
+- **Global install:** `npm install -g haitask` → in any repo: `haitask init` once, then `haitask run` after commits.
+- **Per-project dev dependency:** `npm install haitask --save-dev` → `npx haitask run`.
+- **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.

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "haitask",
+  "version": "0.1.0",
+  "description": "Hidayet AI Task — Generate Jira tasks from Git commits using AI",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "haitask": "src/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "src",
+    "README.md",
+    ".env.example"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "init": "node src/index.js init",
+    "run": "node src/index.js run"
+  },
+  "keywords": [
+    "cli",
+    "jira",
+    "git",
+    "ai",
+    "automation",
+    "commit",
+    "task"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HidayetHidayetov/haitask.git"
+  },
+  "homepage": "https://github.com/HidayetHidayetov/haitask#readme",
+  "bugs": "https://github.com/HidayetHidayetov/haitask/issues",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.5",
+    "execa": "^9.5.2"
+  }
+}

package/src/ai/deepseek.js

@@ -0,0 +1,54 @@
+/**
+ * Deepseek Chat provider (free tier, JSON mode supported).
+ * API: https://api.deepseek.com/v1/chat/completions
+ * Docs: https://platform.deepseek.com/api-docs/
+ */
+
+import { buildPrompt, parseTaskPayload } from './utils.js';
+
+const DEEPSEEK_API_URL = 'https://api.deepseek.com/v1/chat/completions';
+
+/**
+ * Call Deepseek and return task payload for Jira.
+ * @param {{ message: string, branch: string, repoName: string }} commitData
+ * @param {{ ai: { model?: string } }} config
+ * @returns {Promise<{ title: string, description: string, labels: string[] }>}
+ */
+export async function generateDeepseek(commitData, config) {
+  const apiKey = process.env.DEEPSEEK_API_KEY;
+  if (!apiKey?.trim()) {
+    throw new Error('DEEPSEEK_API_KEY is not set. Add it to .env. Get free key at https://platform.deepseek.com/');
+  }
+
+  const model = config?.ai?.model || 'deepseek-chat';
+  const { system, user } = buildPrompt(commitData);
+
+  const response = await fetch(DEEPSEEK_API_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: system },
+        { role: 'user', content: user },
+      ],
+      response_format: { type: 'json_object' },
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Deepseek API error ${response.status}: ${body || response.statusText}`);
+  }
+
+  const data = await response.json();
+  const content = data?.choices?.[0]?.message?.content;
+  if (typeof content !== 'string') {
+    throw new Error('Deepseek response missing choices[0].message.content');
+  }
+
+  return parseTaskPayload(content.trim());
+}

package/src/ai/groq.js

@@ -0,0 +1,56 @@
+/**
+ * Groq provider (free tier, fast inference).
+ * API: https://api.groq.com/openai/v1/chat/completions (OpenAI-compatible)
+ * Docs: https://console.groq.com/docs
+ */
+
+import { buildPrompt, parseTaskPayload } from './utils.js';
+
+const GROQ_API_URL = 'https://api.groq.com/openai/v1/chat/completions';
+
+/**
+ * Call Groq and return task payload for Jira.
+ * @param {{ message: string, branch: string, repoName: string }} commitData
+ * @param {{ ai: { model?: string } }} config
+ * @returns {Promise<{ title: string, description: string, labels: string[] }>}
+ */
+export async function generateGroq(commitData, config) {
+  const apiKey = process.env.GROQ_API_KEY;
+  if (!apiKey?.trim()) {
+    throw new Error(
+      'GROQ_API_KEY is not set. Add it to .env. Get free key at https://console.groq.com/keys'
+    );
+  }
+
+  const model = config?.ai?.model || 'llama-3.1-8b-instant';
+  const { system, user } = buildPrompt(commitData);
+
+  const response = await fetch(GROQ_API_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: system },
+        { role: 'user', content: user },
+      ],
+      response_format: { type: 'json_object' },
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Groq API error ${response.status}: ${body || response.statusText}`);
+  }
+
+  const data = await response.json();
+  const content = data?.choices?.[0]?.message?.content;
+  if (typeof content !== 'string') {
+    throw new Error('Groq response missing choices[0].message.content');
+  }
+
+  return parseTaskPayload(content.trim());
+}

package/src/ai/index.js

@@ -0,0 +1,34 @@
+/**
+ * AI provider abstraction: commit + context → strict JSON task payload.
+ * Supports: OpenAI, Deepseek, Groq (free). Switch via .haitaskrc ai.provider.
+ */
+
+import { generateOpenAI } from './openai.js';
+import { generateDeepseek } from './deepseek.js';
+import { generateGroq } from './groq.js';
+
+// Re-export utils for convenience
+export { buildPrompt, parseTaskPayload } from './utils.js';
+
+const PROVIDERS = ['openai', 'deepseek', 'groq'];
+
+/**
+ * Main entry: generate task payload based on provider in config.
+ * @param {{ message: string, branch: string, repoName: string }} commitData
+ * @param {{ ai: { provider?: string, model?: string } }} config
+ * @returns {Promise<{ title: string, description: string, labels: string[] }>}
+ */
+export async function generateTaskPayload(commitData, config) {
+  const provider = (config?.ai?.provider || 'groq').toLowerCase();
+
+  switch (provider) {
+    case 'openai':
+      return generateOpenAI(commitData, config);
+    case 'deepseek':
+      return generateDeepseek(commitData, config);
+    case 'groq':
+      return generateGroq(commitData, config);
+    default:
+      throw new Error(`Unknown AI provider: ${provider}. Supported: ${PROVIDERS.join(', ')}`);
+  }
+}

package/src/ai/openai.js

@@ -0,0 +1,52 @@
+/**
+ * OpenAI provider implementation.
+ */
+
+import { buildPrompt, parseTaskPayload } from './utils.js';
+
+const OPENAI_API_URL = 'https://api.openai.com/v1/chat/completions';
+
+/**
+ * Call OpenAI and return task payload for Jira.
+ * @param {{ message: string, branch: string, repoName: string }} commitData
+ * @param {{ ai: { model?: string } }} config
+ * @returns {Promise<{ title: string, description: string, labels: string[] }>}
+ */
+export async function generateOpenAI(commitData, config) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey?.trim()) {
+    throw new Error('OPENAI_API_KEY is not set. Add it to .env.');
+  }
+
+  const model = config?.ai?.model || 'gpt-4o-mini';
+  const { system, user } = buildPrompt(commitData);
+
+  const response = await fetch(OPENAI_API_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: system },
+        { role: 'user', content: user },
+      ],
+      response_format: { type: 'json_object' },
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`OpenAI API error ${response.status}: ${body || response.statusText}`);
+  }
+
+  const data = await response.json();
+  const content = data?.choices?.[0]?.message?.content;
+  if (typeof content !== 'string') {
+    throw new Error('OpenAI response missing choices[0].message.content');
+  }
+
+  return parseTaskPayload(content.trim());
+}

package/src/ai/utils.js

@@ -0,0 +1,42 @@
+/**
+ * Shared AI utilities: prompt building and response parsing.
+ */
+
+/**
+ * Build system + user prompt from commit data.
+ * @param {{ message: string, branch: string, repoName: string }} commitData
+ * @returns {{ system: string, user: string }}
+ */
+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"]).`;
+  const user = `Repo: ${repoName}\nBranch: ${branch}\nCommit message:\n${message}\n\nGenerate the JSON object.`;
+  return { system, user };
+}
+
+/**
+ * Parse and validate AI response. Expects { title, description, labels }.
+ * @param {string} raw
+ * @returns {{ title: string, description: string, labels: string[] }}
+ * @throws {Error} If invalid JSON or missing/ wrong types
+ */
+export function parseTaskPayload(raw) {
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`AI response is not valid JSON: ${err.message}`);
+  }
+  if (typeof obj.title !== 'string' || typeof obj.description !== 'string') {
+    throw new Error('AI response missing or invalid title/description (must be strings).');
+  }
+  if (!Array.isArray(obj.labels)) {
+    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 };
+}

package/src/commands/init.js

@@ -0,0 +1,40 @@
+/**
+ * haitask init — Create .haitaskrc, validate .env
+ * Thin handler: delegates to config layer, handles CLI output only.
+ */
+
+import { createDefaultConfigFile, validateEnv } from '../config/init.js';
+import { loadConfig } from '../config/load.js';
+
+export async function runInit() {
+  const { created } = createDefaultConfigFile();
+
+  if (!created) {
+    console.warn('haitask init: .haitaskrc already exists. Not overwriting.');
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('Created .haitaskrc');
+
+  // Load config to check AI provider key
+  let config;
+  try {
+    config = loadConfig();
+  } catch (err) {
+    // Config just created, might not be readable yet, skip AI key check
+    config = null;
+  }
+
+  const { valid, missing } = validateEnv(process.cwd(), config);
+  if (!valid) {
+    console.warn('Add these to .env before running "haitask run":', missing.join(', '));
+    const provider = config?.ai?.provider?.toLowerCase();
+    if (provider === 'groq') console.log('Get free Groq API key at: https://console.groq.com/keys');
+    if (provider === 'deepseek') console.log('Get free Deepseek API key at: https://platform.deepseek.com/');
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('Environment (.env) looks good.');
+}

package/src/commands/run.js

@@ -0,0 +1,51 @@
+/**
+ * haitask run [--dry] — Execute full pipeline
+ * Thin handler: load config, call pipeline, output result.
+ */
+
+import { loadConfig } from '../config/load.js';
+import { runPipeline } from '../core/pipeline.js';
+
+export async function runRun(options = {}) {
+  const dry = options.dry ?? false;
+
+  let config;
+  try {
+    config = loadConfig();
+  } catch (err) {
+    console.error('Config error:', err.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    const result = await runPipeline(config, { dry });
+
+    if (!result.ok) {
+      console.error(result.error || 'Pipeline failed.');
+      process.exitCode = 1;
+      return;
+    }
+
+    if (result.dry) {
+      console.log('Dry run — no Jira issue created.');
+      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 ? '...' : ''));
+      }
+      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);
+    }
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exitCode = 1;
+  }
+}

package/src/config/init.js

@@ -0,0 +1,71 @@
+/**
+ * Config init: create default .haitaskrc, validate .env.
+ * No I/O assumptions — caller can use for messaging.
+ */
+
+import { writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { config as loadEnv } from 'dotenv';
+
+const DEFAULT_RC = {
+  jira: {
+    baseUrl: 'https://your-domain.atlassian.net',
+    projectKey: 'PROJ',
+    issueType: 'Task',
+  },
+  ai: {
+    provider: 'groq',
+    model: 'llama-3.1-8b-instant',
+  },
+  rules: {
+    allowedBranches: ['main', 'develop', 'master'],
+    commitPrefixes: ['feat', 'fix', 'chore'],
+  },
+};
+
+// Note: Only Jira keys are required. AI key depends on provider (DEEPSEEK_API_KEY or OPENAI_API_KEY)
+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
+ */
+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');
+  return { created: true };
+}
+
+/**
+ * Load .env from dir and check required keys.
+ * If config is provided, also validates AI provider key.
+ * @param {string} [dir] - Directory (default: process.cwd())
+ * @param {object} [config] - Optional config to check AI provider key
+ * @returns {{ valid: boolean, missing: string[] }}
+ */
+export function validateEnv(dir = process.cwd(), config = null) {
+  const envPath = resolve(dir, '.env');
+  loadEnv({ path: envPath });
+  const missing = [...REQUIRED_ENV_KEYS];
+
+  // Check AI provider key if config provided
+  if (config?.ai?.provider) {
+    const provider = config.ai.provider.toLowerCase();
+    const aiKeys = {
+      openai: 'OPENAI_API_KEY',
+      deepseek: 'DEEPSEEK_API_KEY',
+      groq: 'GROQ_API_KEY',
+    };
+    const aiKey = aiKeys[provider];
+    if (aiKey && !process.env[aiKey]?.trim()) {
+      missing.push(aiKey);
+    }
+  }
+
+  const filtered = missing.filter((key) => !process.env[key]?.trim());
+  return { valid: filtered.length === 0, missing: filtered };
+}

package/src/config/load.js

@@ -0,0 +1,47 @@
+/**
+ * Load .haitaskrc (single source of truth).
+ * No hardcoded defaults — file must exist and be valid.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+const DEFAULT_CONFIG_PATH = '.haitaskrc';
+
+const REQUIRED_KEYS = ['jira', 'ai', 'rules'];
+
+/**
+ * @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
+    ? resolve(configPath)
+    : resolve(process.cwd(), DEFAULT_CONFIG_PATH);
+
+  if (!existsSync(path)) {
+    throw new Error(`Config not found: ${path}. Run "haitask init" first.`);
+  }
+
+  let raw;
+  try {
+    raw = readFileSync(path, 'utf-8');
+  } catch (err) {
+    throw new Error(`Cannot read config: ${path}. ${err.message}`);
+  }
+
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${path}. ${err.message}`);
+  }
+
+  const missing = REQUIRED_KEYS.filter((key) => !config[key] || typeof config[key] !== 'object');
+  if (missing.length > 0) {
+    throw new Error(`Config missing required sections: ${missing.join(', ')}. Check .haitaskrc.`);
+  }
+
+  return config;
+}

package/src/core/pipeline.js

@@ -0,0 +1,64 @@
+/**
+ * Pipeline: Git → AI → Jira
+ * Orchestrates steps. No direct I/O (no console.log).
+ * Returns structured result for CLI to display.
+ */
+
+import { getLatestCommitData } from '../git/commit.js';
+import { generateTaskPayload } from '../ai/index.js';
+import { createIssue } from '../jira/client.js';
+
+/**
+ * Validate branch and commit prefix from config.rules.
+ * @param {{ message: string, branch: string }} commitData
+ * @param {{ rules?: { allowedBranches?: string[], commitPrefixes?: string[] } }} config
+ * @throws {Error} If validation fails
+ */
+function validateRules(commitData, config) {
+  const { message, branch } = commitData;
+  const rules = config?.rules || {};
+  const allowedBranches = rules.allowedBranches;
+  const commitPrefixes = rules.commitPrefixes;
+
+  if (Array.isArray(allowedBranches) && allowedBranches.length > 0) {
+    if (!allowedBranches.includes(branch)) {
+      throw new Error(
+        `Branch "${branch}" is not allowed. Allowed: ${allowedBranches.join(', ')}. Update .haitaskrc rules.allowedBranches.`
+      );
+    }
+  }
+
+  if (Array.isArray(commitPrefixes) && commitPrefixes.length > 0) {
+    const trimmed = (message || '').trim();
+    const hasPrefix = commitPrefixes.some(
+      (p) => trimmed.startsWith(p + ':') || trimmed.startsWith(p + ' ')
+    );
+    if (!hasPrefix) {
+      throw new Error(
+        `Commit message must start with one of: ${commitPrefixes.map((p) => p + ':').join(', ')}. Update .haitaskrc rules.commitPrefixes or change the commit message.`
+      );
+    }
+  }
+}
+
+/**
+ * Run full pipeline: Git → validate → AI → Jira (unless dry).
+ * @param {object} config - Loaded .haitaskrc
+ * @param {{ dry?: boolean }} options - dry: skip Jira API call
+ * @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 commitData = await getLatestCommitData();
+  validateRules(commitData, config);
+
+  const payload = await generateTaskPayload(commitData, config);
+
+  if (dry) {
+    return { ok: true, dry: true, payload, commitData };
+  }
+
+  const { key } = await createIssue(payload, config);
+  return { ok: true, key, payload, commitData };
+}

package/src/git/commit.js

@@ -0,0 +1,29 @@
+/**
+ * Git data extraction via execa (git CLI).
+ * Returns: { message, branch, repoName } or throws.
+ */
+
+import { execa } from 'execa';
+import { basename } from 'path';
+
+const CWD = process.cwd();
+
+/**
+ * Get latest commit message, current branch, and repo (root folder) name.
+ * @returns {Promise<{ message: string, branch: string, repoName: string }>}
+ * @throws {Error} If not a git repo or git command fails
+ */
+export async function getLatestCommitData() {
+  const [messageResult, branchResult, rootResult] = await Promise.all([
+    execa('git', ['log', '-1', '--pretty=%B'], { cwd: CWD }),
+    execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: CWD }),
+    execa('git', ['rev-parse', '--show-toplevel'], { cwd: CWD }),
+  ]);
+
+  const message = (messageResult.stdout || '').trim();
+  const branch = (branchResult.stdout || '').trim();
+  const repoRoot = (rootResult.stdout || '').trim();
+  const repoName = repoRoot ? basename(repoRoot) : '';
+
+  return { message, branch, repoName };
+}

package/src/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import 'dotenv/config';
+import { program } from 'commander';
+import { runInit } from './commands/init.js';
+import { runRun } from './commands/run.js';
+
+program
+  .name('haitask')
+  .description('HAITASK — Generate Jira tasks from Git commits using AI')
+  .version('0.1.0');
+
+program
+  .command('init')
+  .description('Create .haitaskrc and validate environment')
+  .action(runInit);
+
+program
+  .command('run')
+  .description('Run full pipeline: Git → AI → Jira')
+  .option('--dry', 'Skip Jira API call, run everything else')
+  .action((opts) => runRun(opts));
+
+program.parse();

package/src/jira/client.js

@@ -0,0 +1,128 @@
+/**
+ * Jira REST client: create issue + assign.
+ * Jira Cloud REST API v3. Assignee via dedicated endpoint or issue PUT.
+ */
+
+/**
+ * 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
+    ? paragraphs.map((p) => ({ type: 'paragraph', content: [{ type: 'text', text: p }] }))
+    : [{ type: 'paragraph', content: [{ type: 'text', 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 }}
+ */
+async function assignIssue(baseUrl, issueKey, accountId, auth) {
+  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]);
+  }
+
+  let lastError = '';
+  for (const id of candidates) {
+    if (!id?.trim()) continue;
+
+    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) 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}`;
+    }
+  }
+
+  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="...".`,
+  };
+}
+
+/**
+ * Read assignee accountId: config first, then .env.
+ * .env: use quotes if value contains colon, e.g. JIRA_ACCOUNT_ID="712020:ffdf70f7-..."
+ */
+function getAssigneeAccountId(config) {
+  const fromConfig = (config?.jira?.assigneeAccountId || '').trim();
+  if (fromConfig) return fromConfig;
+  const fromEnv = (process.env.JIRA_ACCOUNT_ID || '').trim();
+  return fromEnv;
+}
+
+/**
+ * Create a Jira issue and optionally assign to JIRA_ACCOUNT_ID.
+ */
+export async function createIssue(payload, config) {
+  const baseUrl = (config?.jira?.baseUrl || process.env.JIRA_BASE_URL || '').replace(/\/$/, '');
+  const email = process.env.JIRA_EMAIL;
+  const token = process.env.JIRA_API_TOKEN;
+
+  if (!baseUrl || !email?.trim() || !token?.trim()) {
+    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 fields = {
+    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') : [],
+  };
+
+  const auth = Buffer.from(`${email}:${token}`, 'utf-8').toString('base64');
+  const 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 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 || ''}`);
+    }
+  }
+
+  return { key, self: data.self };
+}

package/src/utils/index.js

@@ -0,0 +1,5 @@
+/**
+ * Shared utilities (if any).
+ */
+
+export function noop() { }