haitask 0.1.0 → 0.1.2

package/README.md

@@ -28,19 +28,16 @@ git clone https://github.com/HidayetHidayetov/haitask.git && cd haitask && npm i
 
 ## 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)**  
+1. **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`.
+   **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).
+
+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.
 
 3. **Create a Jira issue from the latest commit**  
    After committing:
@@ -56,7 +53,7 @@ git clone https://github.com/HidayetHidayetov/haitask.git && cd haitask && npm i
 
 | Command | Description |
 |--------|-------------|
-| `haitask init` | Create `.haitaskrc` in cwd (no overwrite if present). Validates env. |
+| `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. |
 
@@ -65,7 +62,7 @@ git clone https://github.com/HidayetHidayetov/haitask.git && cd haitask && npm i
 ## 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`).
+- **`.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`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haitask",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Hidayet AI Task — Generate Jira tasks from Git commits using AI",
   "type": "module",
   "main": "src/index.js",
@@ -41,4 +41,4 @@
     "dotenv": "^16.4.5",
     "execa": "^9.5.2"
   }
-}
+}

package/src/commands/init.js

@@ -1,40 +1,112 @@
 /**
- * haitask init — Create .haitaskrc, validate .env
- * Thin handler: delegates to config layer, handles CLI output only.
+ * haitask init — Interactive setup: prompts → .haitaskrc, optional .env placement.
  */
 
+import { createInterface } from 'readline';
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { resolve } from 'path';
 import { createDefaultConfigFile, validateEnv } from '../config/init.js';
 import { loadConfig } from '../config/load.js';
 
+const DEFAULT_MODELS = { groq: 'llama-3.1-8b-instant', deepseek: 'deepseek-chat', openai: 'gpt-4o-mini' };
+
+function question(rl, prompt, defaultVal = '') {
+  const def = defaultVal ? ` (${defaultVal})` : '';
+  return new Promise((resolve) => rl.question(prompt + def + ': ', (ans) => resolve((ans || defaultVal).trim())));
+}
+
+function getEnvExampleContent() {
+  return `# HAITASK — fill in your own API keys (never commit real keys)
+# AI: set the key for the provider in .haitaskrc (ai.provider)
+GROQ_API_KEY=
+DEEPSEEK_API_KEY=
+OPENAI_API_KEY=
+
+# Jira (required)
+JIRA_BASE_URL=
+JIRA_EMAIL=
+JIRA_API_TOKEN=
+JIRA_ACCOUNT_ID=
+`;
+}
+
 export async function runInit() {
-  const { created } = createDefaultConfigFile();
+  const cwd = process.cwd();
+  const rcPath = resolve(cwd, '.haitaskrc');
 
-  if (!created) {
+  if (existsSync(rcPath)) {
     console.warn('haitask init: .haitaskrc already exists. Not overwriting.');
     process.exitCode = 1;
     return;
   }
 
-  console.log('Created .haitaskrc');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    console.log('haitask init — answer the questions (Enter = use default).\n');
+
+    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 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');
+
+    const allowedBranches = allowedBranchesStr.split(',').map((s) => s.trim()).filter(Boolean);
+    const commitPrefixes = commitPrefixesStr.split(',').map((s) => s.trim()).filter(Boolean);
+    const model = DEFAULT_MODELS[aiProvider.toLowerCase()] || DEFAULT_MODELS.groq;
+
+    const config = {
+      jira: { baseUrl: jiraBaseUrl, projectKey: jiraProjectKey, issueType: jiraIssueType },
+      ai: { provider: aiProvider.toLowerCase(), model },
+      rules: { allowedBranches, commitPrefixes },
+    };
+
+    writeFileSync(rcPath, JSON.stringify(config, null, 2), 'utf-8');
+    console.log('\nCreated .haitaskrc');
+
+    const where = await question(rl, 'Where to store API keys? (1 = this project .env, 2 = global ~/.haitask/.env)', '1');
+    const home = process.env.HOME || process.env.USERPROFILE;
+
+    if (where.trim() === '2' && home) {
+      const globalDir = resolve(home, '.haitask');
+      const globalEnv = resolve(globalDir, '.env');
+      if (!existsSync(globalDir)) mkdirSync(globalDir, { recursive: true });
+      if (!existsSync(globalEnv)) {
+        writeFileSync(globalEnv, getEnvExampleContent(), 'utf-8');
+        console.log('Created ~/.haitask/.env — add your API keys there (used by all projects).');
+      } else {
+        console.log('~/.haitask/.env already exists.');
+      }
+    } else {
+      const projectEnv = resolve(cwd, '.env');
+      if (!existsSync(projectEnv)) {
+        writeFileSync(projectEnv, getEnvExampleContent(), 'utf-8');
+        console.log('Created .env in this project — add your API keys there.');
+      } else {
+        console.log('.env already exists in this project.');
+      }
+    }
+  } finally {
+    rl.close();
+  }
 
-  // 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
+  } catch {
     config = null;
   }
 
-  const { valid, missing } = validateEnv(process.cwd(), config);
+  const { valid, missing } = validateEnv(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/');
+    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/');
     process.exitCode = 1;
     return;
   }
 
-  console.log('Environment (.env) looks good.');
+  console.log('\nEnvironment looks good. Run "haitask run" after your next commit.');
 }

package/src/config/env-loader.js

@@ -0,0 +1,37 @@
+/**
+ * Load .env: try cwd first, then ~/.haitask/.env (Option C — hybrid).
+ * So users can have one global .env for all projects or override per repo.
+ */
+
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { config as loadDotenv } from 'dotenv';
+
+const CWD = process.cwd();
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+
+function loadEnv(path) {
+  if (path && existsSync(path)) {
+    loadDotenv({ path });
+  }
+}
+
+/**
+ * Load environment: first .env in current directory, then ~/.haitask/.env.
+ * Call once at CLI entry (e.g. index.js).
+ */
+export function loadEnvFiles() {
+  loadEnv(resolve(CWD, '.env'));
+  if (HOME) {
+    loadEnv(resolve(HOME, '.haitask', '.env'));
+  }
+}
+
+/**
+ * Paths we check for .env (for messaging).
+ */
+export function getEnvPaths() {
+  const paths = [resolve(CWD, '.env')];
+  if (HOME) paths.push(resolve(HOME, '.haitask', '.env'));
+  return paths;
+}

package/src/config/init.js

@@ -5,7 +5,6 @@
 
 import { writeFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
-import { config as loadEnv } from 'dotenv';
 
 const DEFAULT_RC = {
   jira: {
@@ -41,15 +40,13 @@ export function createDefaultConfigFile(dir = process.cwd()) {
 }
 
 /**
- * Load .env from dir and check required keys.
+ * Check required env keys (env is already loaded by loadEnvFiles at CLI entry).
  * If config is provided, also validates AI provider key.
- * @param {string} [dir] - Directory (default: process.cwd())
+ * @param {string} [dir] - Unused; kept for API compatibility
  * @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

package/src/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-import 'dotenv/config';
+import { loadEnvFiles } from './config/env-loader.js';
+loadEnvFiles();
 import { program } from 'commander';
 import { runInit } from './commands/init.js';
 import { runRun } from './commands/run.js';
@@ -8,7 +9,7 @@ import { runRun } from './commands/run.js';
 program
   .name('haitask')
   .description('HAITASK — Generate Jira tasks from Git commits using AI')
-  .version('0.1.0');
+  .version('0.1.1');
 
 program
   .command('init')