haitask 0.3.3 → 0.4.0

package/README.md

@@ -33,6 +33,7 @@ haitask init
 
 Pick a target (1 = Jira, 2 = Trello, 3 = Linear) and answer the prompts. You get a `.haitaskrc` and an optional `.env` template.  
 **Quick mode:** `haitask init --quick` — fewer questions, sensible defaults.
+**Preset mode:** `haitask init --preset jira|trello|linear` — non-interactive starter config.
 
 **2. Add API keys**  
 In the generated `.env`, set the keys for your target and AI provider:
@@ -53,6 +54,7 @@ haitask run
 ```
 
 To try without creating a task: `haitask run --dry`.
+For machine-readable output: `haitask run --dry --json`.
 
 ---
 
@@ -62,12 +64,72 @@ To try without creating a task: `haitask run --dry`.
 |---------|-------------|
 | `haitask init` | Interactive setup: target, AI, rules → writes `.haitaskrc` and optional `.env` |
 | `haitask init --quick` | Minimal prompts: target + required fields only; defaults for AI, branches, prefixes |
+| `haitask init --preset <target>` | Non-interactive preset config for `jira`, `trello`, or `linear` |
 | `haitask check` | Validate `.haitaskrc` + required env keys without running the pipeline |
 | `haitask run` | Creates a task from the latest commit (Jira / Trello / Linear) |
 | `haitask run --dry` | Same flow, but does not create a task |
+| `haitask run --json` | Print machine-readable JSON output (works with `--dry`) |
 | `haitask run --commits N` | Combine the last N commits into one task (e.g. `--commits 3`) |
 | `haitask run --type <type>` | (Jira only) Override issue type for this run (Task, Bug, Story) |
 | `haitask run --status <status>` | (Jira only) Override status after create (Done, "To Do", etc.) |
+| `haitask run --lang <lang>` | Language for task title and description (en, az, tr, ru). Default: en |
+
+---
+
+## Language Support
+
+By default, task titles and descriptions are generated in English. Use `--lang` to generate them in a different language:
+
+```bash
+haitask run --lang az      # Azerbaijani
+haitask run --lang tr      # Turkish
+haitask run --lang ru      # Russian
+haitask run --lang en      # English (default)
+```
+
+Supported languages: `en` (English), `az` (Azerbaijani), `tr` (Turkish), `ru` (Russian).
+
+---
+
+## JSON output (automation)
+
+Use `--json` when integrating with CI/CD or scripts. This guarantees a parseable payload on both success and failure.
+
+```bash
+haitask run --dry --json
+```
+
+Success shape:
+
+```json
+{
+  "ok": true,
+  "dry": true,
+  "skipped": false,
+  "commented": false,
+  "key": null,
+  "url": null,
+  "payload": {
+    "title": "Add login validation",
+    "description": "..."
+  },
+  "commit": {
+    "branch": "main",
+    "commitHash": "abc123...",
+    "repoName": "my-repo",
+    "count": 1
+  }
+}
+```
+
+Failure shape:
+
+```json
+{
+  "ok": false,
+  "error": "Config error: Config not found ..."
+}
+```
 
 ---
 
@@ -94,7 +156,62 @@ To try without creating a task: `haitask run --dry`.
 
 - **Global:** `npm install -g haitask` → run `haitask init` once per repo, then `haitask run` after commits.
 - **Per project:** `npm install haitask --save-dev` → `npx haitask run`.
-- **CI / scripts:** Run `npx haitask run` from the repo root; ensure `.haitaskrc` and env vars are available.
+- **CI / scripts:** Run `npx haitask run --dry --json` from the repo root, parse `ok`, and fail pipeline when `ok === false`.
+
+Example (bash + `jq`):
+
+```bash
+out="$(npx haitask run --dry --json)"
+echo "$out"
+test "$(echo "$out" | jq -r '.ok')" = "true"
+```
+
+---
+
+## GitHub Actions Integration
+
+Add this workflow to `.github/workflows/haitask.yml` for automatic task creation:
+
+```yaml
+name: Create Task from Commit
+
+on:
+  push:
+    branches: [ main, develop ]
+
+jobs:
+  create-task:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '18'
+        
+    - name: Install HAITASK
+      run: npm install -g haitask
+      
+    - name: Create task from latest commit
+      env:
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        # Add your target-specific keys:
+        # JIRA_API_TOKEN: ${{ secrets.JIRA_API_TOKEN }}
+        # TRELLO_TOKEN: ${{ secrets.TRELLO_TOKEN }}
+        # LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
+      run: |
+        if [ -f ".haitaskrc" ]; then
+          haitask run
+        fi
+```
+
+**Setup:**
+1. Copy the workflow to your repo
+2. Add required secrets to GitHub repo settings
+3. Configure `.haitaskrc` in your project root
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "haitask",
-  "version": "0.3.3",
-  "description": "HAITASK — AI-powered task creation from Git commits. Creates issues in Jira, Trello, or Linear from your latest commit message and branch.",
+  "version": "0.4.0",
+  "description": "HAITASK \u2014 AI-powered task creation from Git commits. Creates issues in Jira, Trello, or Linear from your latest commit message and branch.",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/ai/deepseek.js

@@ -9,19 +9,21 @@ 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.
+ * Call Deepseek and return task payload for the configured target.
  * @param {{ message: string, branch: string, repoName: string }} commitData
  * @param {{ ai: { model?: string } }} config
+ * @param {{ lang?: string }} options
  * @returns {Promise<{ title: string, description: string, labels: string[] }>}
  */
-export async function generateDeepseek(commitData, config) {
+export async function generateDeepseek(commitData, config, options = {}) {
   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 { lang } = options || {};
+  const { system, user } = buildPrompt(commitData, config?.target, { lang });
 
   const response = await fetch(DEEPSEEK_API_URL, {
     method: 'POST',
@@ -47,7 +49,7 @@ export async function generateDeepseek(commitData, config) {
   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');
+    throw new TypeError('Deepseek response missing choices[0].message.content');
   }
 
   return parseTaskPayload(content.trim());

package/src/ai/groq.js

@@ -9,12 +9,13 @@ 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.
+ * Call Groq and return task payload for the configured target.
  * @param {{ message: string, branch: string, repoName: string }} commitData
  * @param {{ ai: { model?: string } }} config
+ * @param {{ lang?: string }} options
  * @returns {Promise<{ title: string, description: string, labels: string[] }>}
  */
-export async function generateGroq(commitData, config) {
+export async function generateGroq(commitData, config, options = {}) {
   const apiKey = process.env.GROQ_API_KEY;
   if (!apiKey?.trim()) {
     throw new Error(
@@ -23,7 +24,8 @@ export async function generateGroq(commitData, config) {
   }
 
   const model = config?.ai?.model || 'llama-3.1-8b-instant';
-  const { system, user } = buildPrompt(commitData);
+  const { lang } = options || {};
+  const { system, user } = buildPrompt(commitData, config?.target, { lang });
 
   const response = await fetch(GROQ_API_URL, {
     method: 'POST',
@@ -49,7 +51,7 @@ export async function generateGroq(commitData, config) {
   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');
+    throw new TypeError('Groq response missing choices[0].message.content');
   }
 
   return parseTaskPayload(content.trim());

package/src/ai/index.js

@@ -16,18 +16,20 @@ 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
+ * @param {{ lang?: string }} options
  * @returns {Promise<{ title: string, description: string, labels: string[] }>}
  */
-export async function generateTaskPayload(commitData, config) {
+export async function generateTaskPayload(commitData, config, options = {}) {
   const provider = (config?.ai?.provider || 'groq').toLowerCase();
+  const { lang } = options || {};
 
   switch (provider) {
     case 'openai':
-      return generateOpenAI(commitData, config);
+      return generateOpenAI(commitData, config, { lang });
     case 'deepseek':
-      return generateDeepseek(commitData, config);
+      return generateDeepseek(commitData, config, { lang });
     case 'groq':
-      return generateGroq(commitData, config);
+      return generateGroq(commitData, config, { lang });
     default:
       throw new Error(`Unknown AI provider: ${provider}. Supported: ${PROVIDERS.join(', ')}`);
   }

package/src/ai/openai.js

@@ -7,19 +7,21 @@ 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.
+ * Call OpenAI and return task payload for the configured target.
  * @param {{ message: string, branch: string, repoName: string }} commitData
  * @param {{ ai: { model?: string } }} config
+ * @param {{ lang?: string }} options
  * @returns {Promise<{ title: string, description: string, labels: string[] }>}
  */
-export async function generateOpenAI(commitData, config) {
+export async function generateOpenAI(commitData, config, options = {}) {
   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 { lang } = options || {};
+  const { system, user } = buildPrompt(commitData, config?.target, { lang });
 
   const response = await fetch(OPENAI_API_URL, {
     method: 'POST',
@@ -45,7 +47,7 @@ export async function generateOpenAI(commitData, config) {
   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');
+    throw new TypeError('OpenAI response missing choices[0].message.content');
   }
 
   return parseTaskPayload(content.trim());

package/src/ai/utils.js

@@ -4,30 +4,75 @@
 
 const CONVENTIONAL_PREFIXES = /^(feat|fix|chore|docs|style|refactor|test|build|ci):\s*/i;
 
+const LANG_ALIASES = {
+  en: 'en',
+  english: 'en',
+  az: 'az',
+  azerbaijani: 'az',
+  'az-az': 'az',
+  tr: 'tr',
+  turkish: 'tr',
+  'tr-tr': 'tr',
+  ru: 'ru',
+  russian: 'ru',
+  'ru-ru': 'ru',
+};
+
+const LANG_INSTRUCTIONS = {
+  en: 'Write the title and description in English.',
+  az: 'Write the title and description in Azerbaijani (Azərbaycan) language.',
+  tr: 'Write the title and description in Turkish language.',
+  ru: 'Write the title and description in Russian language.',
+};
+
+function normalizeLang(lang) {
+  if (!lang) return 'en';
+  const normalized = lang.toLowerCase().trim();
+  return LANG_ALIASES[normalized] || 'en';
+}
+
 /**
  * Build system + user prompt from commit data.
  * @param {{ message: string, branch: string, repoName: string }} commitData
+ * @param {string} [target='jira']
+ * @param {{ lang?: string }} options
  * @returns {{ system: string, user: string }}
  */
 const BATCH_SEP = '\n\n---\n\n';
 
-export function buildPrompt(commitData) {
+const TARGET_META = {
+  jira: { displayName: 'Jira', workItem: 'issue', priorityField: true },
+  trello: { displayName: 'Trello', workItem: 'card', priorityField: false },
+  linear: { displayName: 'Linear', workItem: 'issue', priorityField: true },
+};
+
+export function buildPrompt(commitData, target = 'jira', options = {}) {
   const { message, branch, repoName } = commitData;
   const isBatch = message.includes(BATCH_SEP);
+  const normalizedTarget = (target || 'jira').toLowerCase();
+  const meta = TARGET_META[normalizedTarget] || TARGET_META.jira;
   const batchHint = isBatch
     ? ' The user input may contain multiple commits separated by "---"; produce one task that summarizes all of them.\n\n'
     : '';
-  const system = `You generate a Jira task from a Git commit. Reply with a single JSON object only, no markdown or extra text.
-${batchHint}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.
+  const priorityRule = meta.priorityField
+    ? '- "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.'
+    : '- "priority": Still provide one of "Highest", "High", "Medium", "Low", "Lowest". Some targets may not have a native priority field; it can be used for description context.';
+
+  const lang = normalizeLang(options?.lang);
+  const langInstruction = LANG_INSTRUCTIONS[lang] || LANG_INSTRUCTIONS.en;
+
+  const system = `You generate a ${meta.displayName} ${meta.workItem} from a Git commit. Reply with a single JSON object only, no markdown or extra text.
+${batchHint}${langInstruction}
+Keys:
+- "title": Short, formal ${meta.displayName} ${meta.workItem} summary (professional wording). Do NOT copy the commit message verbatim. Rewrite as a clear, formal title. Do NOT include prefixes like feat:, fix:, chore: in the title.
+- "description": Detailed description in plain language, suitable for ${meta.displayName}. 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.`;
+${priorityRule}`;
   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'];
+const VALID_PRIORITIES = new Set(['Highest', 'High', 'Medium', 'Low', 'Lowest']);
 
 /**
  * Parse and validate AI response. Expects { title, description, labels, priority? }.
@@ -43,15 +88,15 @@ export function parseTaskPayload(raw) {
     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).');
+    throw new TypeError('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.');
+    throw new TypeError('AI response labels must be an array of strings.');
   }
   const labels = obj.labels.filter((l) => typeof l === 'string');
   const rawTitle = (obj.title || '').trim();
   const title = rawTitle.replace(CONVENTIONAL_PREFIXES, '').trim() || rawTitle;
   const rawPriority = (obj.priority || 'Medium').trim();
-  const priority = VALID_PRIORITIES.includes(rawPriority) ? rawPriority : 'Medium';
+  const priority = VALID_PRIORITIES.has(rawPriority) ? rawPriority : 'Medium';
   return { title, description: obj.description.trim(), labels, priority };
 }

package/src/commands/init.js

@@ -7,6 +7,7 @@ import { writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { validateEnv } from '../config/init.js';
 import { loadConfig } from '../config/load.js';
+import { VALID_TARGETS } from '../config/constants.js';
 
 const DEFAULT_MODELS = { groq: 'llama-3.1-8b-instant', deepseek: 'deepseek-chat', openai: 'gpt-4o-mini' };
 
@@ -136,8 +137,79 @@ const DEFAULT_RULES = {
 };
 const DEFAULT_AI = { provider: 'groq', model: DEFAULT_MODELS.groq };
 
+function normalizePresetTarget(preset) {
+  const target = (preset || '').trim().toLowerCase();
+  if (!target) return null;
+  if (!VALID_TARGETS.includes(target)) return '__invalid__';
+  return target;
+}
+
+function buildPresetConfig(target) {
+  if (target === 'trello') {
+    return {
+      target: 'trello',
+      trello: { listId: 'YOUR_TRELLO_LIST_ID' },
+      ai: DEFAULT_AI,
+      rules: DEFAULT_RULES,
+    };
+  }
+  if (target === 'linear') {
+    return {
+      target: 'linear',
+      linear: { teamId: 'YOUR_LINEAR_TEAM_ID' },
+      ai: DEFAULT_AI,
+      rules: DEFAULT_RULES,
+    };
+  }
+  return {
+    target: 'jira',
+    jira: {
+      baseUrl: 'https://your-domain.atlassian.net',
+      projectKey: 'PROJ',
+      issueType: 'Task',
+      transitionToStatus: 'Done',
+    },
+    ai: DEFAULT_AI,
+    rules: DEFAULT_RULES,
+  };
+}
+
+async function buildInteractiveConfig(rl, quick) {
+  const targetAnswer = await question(rl, 'Target: 1 = Jira, 2 = Trello, 3 = Linear', '1');
+  const targetMap = { '1': 'jira', '2': 'trello', '3': 'linear' };
+  const target = targetMap[targetAnswer] || 'jira';
+
+  let rules;
+  let ai;
+  if (quick) {
+    rules = DEFAULT_RULES;
+    ai = DEFAULT_AI;
+  } else {
+    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');
+    rules = {
+      allowedBranches: parseList(allowedBranchesStr),
+      commitPrefixes: parseList(commitPrefixesStr),
+    };
+    ai = {
+      provider: aiProvider.toLowerCase(),
+      model: DEFAULT_MODELS[aiProvider.toLowerCase()] || DEFAULT_MODELS.groq,
+    };
+  }
+
+  let config;
+  if (target === 'jira') config = await askJiraConfig(rl, ai, rules);
+  else if (target === 'trello') config = quick ? await askTrelloConfigQuick(rl, ai, rules) : await askTrelloConfig(rl, ai, rules);
+  else config = await askLinearConfig(rl, ai, rules);
+
+  return { target, config };
+}
+
 export async function runInit(options = {}) {
   const quick = options.quick === true;
+  const presetTarget = normalizePresetTarget(options.preset);
+  const usePreset = presetTarget && presetTarget !== '__invalid__';
   const cwd = process.cwd();
   const rcPath = resolve(cwd, '.haitaskrc');
 
@@ -147,38 +219,33 @@ export async function runInit(options = {}) {
     return;
   }
 
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-
-  try {
-    console.log(quick ? 'haitask init --quick (minimal questions, defaults for the rest).\n' : 'haitask init — answer the questions (Enter = use default).\n');
+  if (presetTarget === '__invalid__') {
+    console.error(`Invalid preset target "${options.preset}". Use one of: ${VALID_TARGETS.join(', ')}.`);
+    process.exitCode = 1;
+    return;
+  }
 
-    const targetAnswer = await question(rl, 'Target: 1 = Jira, 2 = Trello, 3 = Linear', '1');
-    const targetMap = { '1': 'jira', '2': 'trello', '3': 'linear' };
-    const target = targetMap[targetAnswer] || 'jira';
+  if (usePreset) {
+    const config = buildPresetConfig(presetTarget);
+    writeFileSync(rcPath, JSON.stringify(config, null, 2), 'utf-8');
+    console.log(`Created .haitaskrc from preset: ${presetTarget}`);
+    writeEnvFile(cwd, presetTarget, '1');
 
-    let rules;
-    let ai;
-    if (quick) {
-      rules = DEFAULT_RULES;
-      ai = DEFAULT_AI;
-    } else {
-      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');
-      rules = {
-        allowedBranches: parseList(allowedBranchesStr),
-        commitPrefixes: parseList(commitPrefixesStr),
-      };
-      ai = {
-        provider: aiProvider.toLowerCase(),
-        model: DEFAULT_MODELS[aiProvider.toLowerCase()] || DEFAULT_MODELS.groq,
-      };
+    const { valid, missing } = validateEnv(cwd, config);
+    if (!valid) {
+      printEnvHints(config, missing);
+      process.exitCode = 1;
+      return;
     }
+    console.log('\nEnvironment looks good. Run "haitask run" after your next commit.');
+    return;
+  }
 
-    let config;
-    if (target === 'jira') config = await askJiraConfig(rl, ai, rules);
-    else if (target === 'trello') config = quick ? await askTrelloConfigQuick(rl, ai, rules) : await askTrelloConfig(rl, ai, rules);
-    else config = await askLinearConfig(rl, ai, rules);
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    console.log(quick ? 'haitask init --quick (minimal questions, defaults for the rest).\n' : 'haitask init — answer the questions (Enter = use default).\n');
+    const { target, config } = await buildInteractiveConfig(rl, quick);
 
     writeFileSync(rcPath, JSON.stringify(config, null, 2), 'utf-8');
     console.log('\nCreated .haitaskrc');

package/src/commands/run.js

@@ -13,58 +13,105 @@ function getDisplayUrl(config, key, resultUrl) {
   return target === 'jira' ? buildJiraUrl(config, key) : key;
 }
 
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+function printFailure(json, message, prefix = null) {
+  if (json) {
+    printJson({ ok: false, error: prefix ? `${prefix}: ${message}` : message });
+  } else if (prefix) {
+    console.error(`${prefix}:`, message);
+  } else {
+    console.error(message);
+  }
+  process.exitCode = 1;
+}
+
+function toJsonResult(result, config) {
+  const displayUrl = getDisplayUrl(config, result.key, result.url);
+  return {
+    ok: true,
+    dry: !!result.dry,
+    skipped: !!result.skipped,
+    commented: !!result.commented,
+    key: result.key || null,
+    url: displayUrl || null,
+    payload: result.payload || null,
+    commit: result.commitData
+      ? {
+          branch: result.commitData.branch,
+          commitHash: result.commitData.commitHash,
+          repoName: result.commitData.repoName,
+          count: result.commitData.count || 1,
+        }
+      : null,
+  };
+}
+
+function printDryResult(result) {
+  console.log('Dry run — no task created.');
+  if (result.commented) {
+    console.log('Would add comment to existing:', result.key);
+    return;
+  }
+  const msg = result.commitData?.message || '';
+  const preview = msg.includes('\n\n---\n\n') ? `${result.commitData?.count ?? '?'} commits` : msg.split('\n')[0] || '';
+  console.log('Commit(s):', preview);
+  console.log('Would create task:', result.payload?.title || '');
+  if (result.payload?.description) {
+    const desc = result.payload.description;
+    console.log('Description (preview):', desc.slice(0, 120) + (desc.length > 120 ? '...' : ''));
+  }
+}
+
+function printSuccessResult(result, config) {
+  if (result.dry) {
+    printDryResult(result);
+    return;
+  }
+
+  const displayUrl = getDisplayUrl(config, result.key, result.url);
+  if (result.skipped) {
+    console.log('Already created for this commit:', result.key);
+  } else if (result.commented) {
+    console.log('Added comment to:', result.key);
+  } else {
+    console.log('Created task:', result.key);
+  }
+  if (displayUrl && displayUrl !== result.key) console.log(displayUrl);
+}
+
 export async function runRun(options = {}) {
   const dry = options.dry ?? false;
+  const json = options.json ?? false;
   const type = options.type?.trim() || undefined;
   const status = options.status?.trim() || undefined;
-  const commits = options.commits != null ? Number(options.commits) : 1;
+  const commits = Number(options.commits ?? 1);
+  const lang = options.lang?.trim() || undefined;
 
   let config;
   try {
     config = loadConfig();
   } catch (err) {
-    console.error('Config error:', err.message);
-    process.exitCode = 1;
+    printFailure(json, err.message, 'Config error');
     return;
   }
 
   try {
-    const result = await runPipeline(config, { dry, issueType: type, transitionToStatus: status, commits });
+    const result = await runPipeline(config, { dry, issueType: type, transitionToStatus: status, commits, lang });
 
     if (!result.ok) {
-      console.error(result.error || 'Pipeline failed.');
-      process.exitCode = 1;
+      printFailure(json, result.error || 'Pipeline failed.');
       return;
     }
 
-    if (result.dry) {
-      console.log('Dry run — no task created.');
-      if (result.commented) {
-        console.log('Would add comment to existing:', result.key);
-      } else {
-        const msg = result.commitData?.message || '';
-        const preview = msg.includes('\n\n---\n\n') ? `${result.commitData?.count ?? '?'} commits` : msg.split('\n')[0] || '';
-        console.log('Commit(s):', preview);
-        console.log('Would create task:', result.payload?.title || '');
-        if (result.payload?.description) {
-          const desc = result.payload.description;
-          console.log('Description (preview):', desc.slice(0, 120) + (desc.length > 120 ? '...' : ''));
-        }
-      }
+    if (json) {
+      printJson(toJsonResult(result, config));
       return;
     }
-
-    const displayUrl = getDisplayUrl(config, result.key, result.url);
-    if (result.skipped) {
-      console.log('Already created for this commit:', result.key);
-    } else if (result.commented) {
-      console.log('Added comment to:', result.key);
-    } else {
-      console.log('Created task:', result.key);
-    }
-    if (displayUrl && displayUrl !== result.key) console.log(displayUrl);
+    printSuccessResult(result, config);
   } catch (err) {
-    console.error('Error:', err.message);
-    process.exitCode = 1;
+    printFailure(json, err.message, 'Error');
   }
 }

package/src/core/pipeline.js

@@ -51,11 +51,11 @@ export function validateRules(commitData, config) {
 /**
  * Run full pipeline: Git → validate → AI → target (unless dry).
  * @param {object} config - Loaded .haitaskrc
- * @param {{ dry?: boolean, issueType?: string, transitionToStatus?: string, commits?: number }} options
+ * @param {{ dry?: boolean, issueType?: string, transitionToStatus?: string, commits?: number, lang?: string }} options
  * @returns {Promise<{ ok: boolean, dry?: boolean, key?: string, url?: string, payload?: object, commitData?: object, error?: string }>}
  */
 export async function runPipeline(config, options = {}) {
-  const { dry = false, issueType: typeOverride, transitionToStatus: statusOverride, commits: commitsOpt } = options;
+  const { dry = false, issueType: typeOverride, transitionToStatus: statusOverride, commits: commitsOpt, lang } = options;
   const numCommits = Math.max(1, Number(commitsOpt) || 1);
 
   const commitData = numCommits > 1 ? await getLatestCommitsData(numCommits) : await getLatestCommitData();
@@ -71,7 +71,7 @@ export async function runPipeline(config, options = {}) {
     return { ok: true, commented: true, key, url, commitData };
   }
 
-  const payload = await generateTaskPayload(commitData, config);
+  const payload = await generateTaskPayload(commitData, config, { lang });
 
   if (dry) {
     return { ok: true, dry: true, payload, commitData };

package/src/index.js

@@ -21,6 +21,7 @@ program
   .command('init')
   .description('Create .haitaskrc and validate environment')
   .option('--quick', 'Use defaults (target + minimal questions); one Enter for Jira/Trello/Linear choice')
+  .option('--preset <target>', 'Preset target without target prompt (jira|trello|linear)')
   .action((opts) => runInit(opts));
 
 program
@@ -32,9 +33,11 @@ program
   .command('run')
   .description('Run full pipeline: Git → AI → target (Jira, Trello, or Linear)')
   .option('--dry', 'Skip creating task, run everything else')
+  .option('--json', 'Print machine-readable JSON output')
   .option('-c, --commits <n>', 'Number of commits to combine into one task (default: 1)', '1')
   .option('-t, --type <type>', 'Jira issue type for this run (e.g. Task, Bug, Story). Overrides .haitaskrc jira.issueType')
   .option('-s, --status <status>', 'Jira transition-to status after create (e.g. Done, "To Do"). Overrides .haitaskrc jira.transitionToStatus')
+  .option('-l, --lang <language>', 'Language for task title and description (en, az, tr, ru). Default: en')
   .action((opts) => runRun(opts));
 
 program.parse();

package/src/linear/client.js

@@ -15,6 +15,59 @@ const CREATE_ISSUE_MUTATION = `
   }
 `;
 
+const TEAM_LABELS_QUERY = `
+  query TeamLabels($teamId: String!) {
+    team(id: $teamId) {
+      labels {
+        nodes { id name }
+      }
+    }
+  }
+`;
+
+function toLinearPriority(priority) {
+  const p = (priority || '').trim();
+  if (p === 'Highest') return 1;
+  if (p === 'High') return 2;
+  if (p === 'Low' || p === 'Lowest') return 4;
+  return 3;
+}
+
+async function resolveLinearLabelIds(apiKey, teamId, labels) {
+  const desired = (Array.isArray(labels) ? labels : [])
+    .filter((v) => typeof v === 'string' && v.trim())
+    .map((v) => v.trim().toLowerCase());
+  if (desired.length === 0) return [];
+
+  try {
+    const res = await fetch(LINEAR_GRAPHQL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        Authorization: apiKey,
+      },
+      body: JSON.stringify({
+        query: TEAM_LABELS_QUERY,
+        variables: { teamId },
+      }),
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const nodes = data?.data?.team?.labels?.nodes;
+    if (!Array.isArray(nodes)) return [];
+
+    const byName = new Map();
+    for (const node of nodes) {
+      const key = typeof node?.name === 'string' ? node.name.trim().toLowerCase() : '';
+      if (key && typeof node?.id === 'string') byName.set(key, node.id);
+    }
+    return desired.map((name) => byName.get(name)).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Create a Linear issue from AI payload. Same interface as Jira/Trello: returns { key, url }.
  * @param {object} payload - { title, description, labels, priority } from AI
@@ -37,6 +90,8 @@ export async function createTask(payload, config) {
 
   const title = (payload?.title || '').trim() || 'Untitled';
   const description = (payload?.description || '').trim() || '';
+  const priority = toLinearPriority(payload?.priority);
+  const labelIds = await resolveLinearLabelIds(apiKey, teamId, payload?.labels);
 
   const res = await fetch(LINEAR_GRAPHQL, {
     method: 'POST',
@@ -52,6 +107,8 @@ export async function createTask(payload, config) {
           teamId,
           title,
           ...(description && { description }),
+          ...(Number.isFinite(priority) && { priority }),
+          ...(labelIds.length > 0 && { labelIds }),
         },
       },
     }),

package/src/trello/client.js

@@ -8,6 +8,50 @@ import { getHttpHint } from '../utils/http-hints.js';
 
 const TRELLO_API = 'https://api.trello.com/1';
 
+function withPriorityInDescription(description, priority) {
+  const p = (priority || '').trim();
+  if (!p) return description;
+  return `Priority: ${p}\n\n${description}`.trim();
+}
+
+async function resolveTrelloLabelIds(apiKey, token, listId, labels) {
+  const desired = (Array.isArray(labels) ? labels : [])
+    .filter((v) => typeof v === 'string' && v.trim())
+    .map((v) => v.trim().toLowerCase());
+  if (desired.length === 0) return [];
+
+  try {
+    const query = new URLSearchParams({ key: apiKey, token });
+    const listRes = await fetch(`${TRELLO_API}/lists/${encodeURIComponent(listId)}?fields=idBoard&${query.toString()}`, {
+      method: 'GET',
+      headers: { Accept: 'application/json' },
+    });
+    if (!listRes.ok) return [];
+    const listData = await listRes.json();
+    const boardId = listData?.idBoard;
+    if (!boardId || !TRELLO_ID_REGEX.test(boardId)) return [];
+
+    const labelsRes = await fetch(
+      `${TRELLO_API}/boards/${encodeURIComponent(boardId)}/labels?fields=id,name&limit=1000&${query.toString()}`,
+      { method: 'GET', headers: { Accept: 'application/json' } }
+    );
+    if (!labelsRes.ok) return [];
+    const boardLabels = await labelsRes.json();
+    if (!Array.isArray(boardLabels)) return [];
+
+    const byName = new Map();
+    for (const label of boardLabels) {
+      const name = typeof label?.name === 'string' ? label.name.trim().toLowerCase() : '';
+      if (name && typeof label?.id === 'string' && TRELLO_ID_REGEX.test(label.id)) {
+        byName.set(name, label.id);
+      }
+    }
+    return desired.map((name) => byName.get(name)).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Create a Trello card from AI payload. Same interface as Jira adapter: returns { key, url }.
  * @param {object} payload - { title, description, labels, priority } from AI
@@ -36,7 +80,7 @@ export async function createTask(payload, config) {
   }
 
   const name = (payload?.title || '').trim() || 'Untitled';
-  const desc = (payload?.description || '').trim() || '';
+  const desc = withPriorityInDescription((payload?.description || '').trim() || '', payload?.priority);
 
   const query = new URLSearchParams({ key: apiKey, token });
   const body = { idList: listId, name, desc };
@@ -45,12 +89,16 @@ export async function createTask(payload, config) {
   const memberId = trello.memberId?.trim() || process.env.TRELLO_MEMBER_ID?.trim();
   if (memberId && TRELLO_ID_REGEX.test(memberId)) body.idMembers = [memberId];
 
-  const labelIds = trello.labelIds;
-  if (Array.isArray(labelIds) && labelIds.length > 0) {
-    body.idLabels = labelIds
+  const configLabelIds = Array.isArray(trello.labelIds)
+    ? trello.labelIds
       .filter((id) => typeof id === 'string' && id.trim())
       .map((id) => id.trim())
-      .filter((id) => TRELLO_ID_REGEX.test(id));
+      .filter((id) => TRELLO_ID_REGEX.test(id))
+    : [];
+  const aiLabelIds = await resolveTrelloLabelIds(apiKey, token, listId, payload?.labels);
+  const mergedLabelIds = [...new Set([...configLabelIds, ...aiLabelIds])];
+  if (mergedLabelIds.length > 0) {
+    body.idLabels = mergedLabelIds;
   }
 
   const url = `${TRELLO_API}/cards?${query.toString()}`;