jira-ai 0.1.0 → 0.2.2

package/dist/cli.js

@@ -16,14 +16,26 @@ const run_jql_1 = require("./commands/run-jql");
 const update_description_1 = require("./commands/update-description");
 const add_comment_1 = require("./commands/add-comment");
 const about_1 = require("./commands/about");
+const auth_1 = require("./commands/auth");
 const settings_1 = require("./lib/settings");
 // Load environment variables
 dotenv_1.default.config();
-// Validate environment variables
-(0, utils_1.validateEnvVars)();
-// Helper function to wrap commands with permission check
-function withPermission(commandName, commandFn) {
+// Create CLI program
+const program = new commander_1.Command();
+program
+    .name('jira-ai')
+    .description('CLI tool for interacting with Atlassian Jira')
+    .version('1.0.0');
+// Middleware to validate credentials for commands that need them
+const validateCredentials = () => {
+    (0, utils_1.validateEnvVars)();
+};
+// Helper function to wrap commands with permission check and credential validation
+function withPermission(commandName, commandFn, skipValidation = false) {
     return async (...args) => {
+        if (!skipValidation) {
+            validateCredentials();
+        }
         if (!(0, settings_1.isCommandAllowed)(commandName)) {
             console.error(chalk_1.default.red(`\n❌ Command '${commandName}' is not allowed.`));
             console.log(chalk_1.default.gray('Allowed commands: ' + (0, settings_1.getAllowedCommands)().join(', ')));
@@ -33,12 +45,11 @@ function withPermission(commandName, commandFn) {
         return commandFn(...args);
     };
 }
-// Create CLI program
-const program = new commander_1.Command();
+// Auth command (always allowed, skips validation)
 program
-    .name('jira-ai')
-    .description('CLI tool for interacting with Atlassian Jira')
-    .version('1.0.0');
+    .command('auth')
+    .description('Set up Jira authentication credentials')
+    .action(() => (0, auth_1.authCommand)());
 // Me command
 program
     .command('me')

package/dist/commands/about.js

@@ -76,7 +76,7 @@ async function aboutCommand() {
     console.log(chalk_1.default.bold('For detailed help on any command, run:'));
     console.log(chalk_1.default.green('  jira-ai <command> --help\n'));
     console.log(chalk_1.default.bold('Configuration:'));
-    console.log('  Settings are managed in settings.yaml');
+    console.log(`  Settings file: ${chalk_1.default.cyan((0, settings_1.getSettingsPath)())}`);
     const allowedProjects = (0, settings_1.getAllowedProjects)();
     console.log(`  - Projects: ${allowedProjects.includes('all') ? 'All allowed' : allowedProjects.join(', ')}`);
     console.log(`  - Commands: ${isAllAllowed ? 'All allowed' : allowedCommandsList.join(', ')}\n`);

package/dist/commands/auth.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authCommand = authCommand;
+const readline_1 = __importDefault(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const jira_client_1 = require("../lib/jira-client");
+const auth_storage_1 = require("../lib/auth-storage");
+const rl = readline_1.default.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+function ask(question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+function askSecret(question) {
+    return new Promise((resolve) => {
+        // Hide input for secret (basic implementation)
+        const stdin = process.stdin;
+        process.stdout.write(question);
+        // We can't easily hide characters in standard readline without some complex logic
+        // or external libraries. For now, we'll just use regular question but we'll 
+        // mention it's a secret.
+        rl.question('', (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+async function authCommand() {
+    console.log(chalk_1.default.cyan('\n--- Jira Authentication Setup ---\n'));
+    try {
+        const host = await ask('Jira URL (e.g., https://your-domain.atlassian.net): ');
+        if (!host) {
+            console.error(chalk_1.default.red('URL is required.'));
+            process.exit(1);
+        }
+        const email = await ask('Email: ');
+        if (!email) {
+            console.error(chalk_1.default.red('Email is required.'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.gray('Get your API token from: https://id.atlassian.com/manage-profile/security/api-tokens'));
+        const apiToken = await ask('API Token: ');
+        if (!apiToken) {
+            console.error(chalk_1.default.red('API Token is required.'));
+            process.exit(1);
+        }
+        const spinner = (0, ora_1.default)('Verifying credentials...').start();
+        try {
+            const tempClient = (0, jira_client_1.createTemporaryClient)(host, email, apiToken);
+            const user = await tempClient.myself.getCurrentUser();
+            spinner.succeed(chalk_1.default.green('Authentication successful!'));
+            console.log(chalk_1.default.blue(`\nWelcome, ${user.displayName} (${user.emailAddress})`));
+            (0, auth_storage_1.saveCredentials)({ host, email, apiToken });
+            console.log(chalk_1.default.green('\nCredentials saved successfully to ~/.jira-ai/config.json'));
+            console.log(chalk_1.default.gray('These credentials will be used for future commands on this machine.'));
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red('Authentication failed.'));
+            console.error(chalk_1.default.red(`Error: ${error.message || 'Invalid credentials'}`));
+            if (error.response && error.response.status === 401) {
+                console.error(chalk_1.default.yellow('Hint: Check if your email and API token are correct.'));
+            }
+            process.exit(1);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/lib/auth-storage.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveCredentials = saveCredentials;
+exports.loadCredentials = loadCredentials;
+exports.hasCredentials = hasCredentials;
+exports.clearCredentials = clearCredentials;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.jira-ai');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+/**
+ * Save credentials to local storage
+ */
+function saveCredentials(creds) {
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(creds, null, 2), {
+        mode: 0o600, // Read/write for owner only
+    });
+}
+/**
+ * Load credentials from local storage
+ */
+function loadCredentials() {
+    if (!fs_1.default.existsSync(CONFIG_FILE)) {
+        return null;
+    }
+    try {
+        const data = fs_1.default.readFileSync(CONFIG_FILE, 'utf8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Check if credentials exist
+ */
+function hasCredentials() {
+    return fs_1.default.existsSync(CONFIG_FILE);
+}
+/**
+ * Clear stored credentials
+ */
+function clearCredentials() {
+    if (fs_1.default.existsSync(CONFIG_FILE)) {
+        fs_1.default.unlinkSync(CONFIG_FILE);
+    }
+}

package/dist/lib/jira-client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getJiraClient = getJiraClient;
+exports.createTemporaryClient = createTemporaryClient;
 exports.getCurrentUser = getCurrentUser;
 exports.getProjects = getProjects;
 exports.getTaskWithDetails = getTaskWithDetails;
@@ -10,24 +11,61 @@ exports.updateIssueDescription = updateIssueDescription;
 exports.addIssueComment = addIssueComment;
 const jira_js_1 = require("jira.js");
 const utils_1 = require("./utils");
+const auth_storage_1 = require("./auth-storage");
 let jiraClient = null;
 /**
  * Get or create Jira client instance
  */
 function getJiraClient() {
     if (!jiraClient) {
-        jiraClient = new jira_js_1.Version3Client({
-            host: process.env.JIRA_HOST,
-            authentication: {
-                basic: {
-                    email: process.env.JIRA_USER_EMAIL,
-                    apiToken: process.env.JIRA_API_TOKEN,
+        const host = process.env.JIRA_HOST;
+        const email = process.env.JIRA_USER_EMAIL;
+        const apiToken = process.env.JIRA_API_TOKEN;
+        if (host && email && apiToken) {
+            jiraClient = new jira_js_1.Version3Client({
+                host,
+                authentication: {
+                    basic: {
+                        email,
+                        apiToken,
+                    },
                 },
-            },
-        });
+            });
+        }
+        else {
+            const storedCreds = (0, auth_storage_1.loadCredentials)();
+            if (storedCreds) {
+                jiraClient = new jira_js_1.Version3Client({
+                    host: storedCreds.host,
+                    authentication: {
+                        basic: {
+                            email: storedCreds.email,
+                            apiToken: storedCreds.apiToken,
+                        },
+                    },
+                });
+            }
+            else {
+                throw new Error('Jira credentials not found. Please set environment variables or run "jira-ai auth"');
+            }
+        }
     }
     return jiraClient;
 }
+/**
+ * Initialize a temporary Jira client for verification
+ */
+function createTemporaryClient(host, email, apiToken) {
+    return new jira_js_1.Version3Client({
+        host,
+        authentication: {
+            basic: {
+                email,
+                apiToken,
+            },
+        },
+    });
+}
 /**
  * Get current user information
  */

package/dist/lib/settings.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSettingsPath = getSettingsPath;
 exports.loadSettings = loadSettings;
 exports.isProjectAllowed = isProjectAllowed;
 exports.isCommandAllowed = isCommandAllowed;
@@ -11,23 +12,55 @@ exports.getAllowedCommands = getAllowedCommands;
 exports.__resetCache__ = __resetCache__;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
+const chalk_1 = __importDefault(require("chalk"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.jira-ai');
+const SETTINGS_FILE = path_1.default.join(CONFIG_DIR, 'settings.yaml');
 let cachedSettings = null;
+function getSettingsPath() {
+    return SETTINGS_FILE;
+}
 function loadSettings() {
     if (cachedSettings) {
         return cachedSettings;
     }
-    const settingsPath = path_1.default.join(process.cwd(), 'settings.yaml');
-    if (!fs_1.default.existsSync(settingsPath)) {
-        console.warn('Warning: settings.yaml not found. Using default settings (all allowed).');
-        cachedSettings = {
-            projects: ['all'],
-            commands: ['all']
-        };
-        return cachedSettings;
+    // Ensure config directory exists
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    if (!fs_1.default.existsSync(SETTINGS_FILE)) {
+        // Check if settings.yaml exists in current working directory (migration/backward compatibility)
+        const localSettingsPath = path_1.default.join(process.cwd(), 'settings.yaml');
+        if (fs_1.default.existsSync(localSettingsPath)) {
+            try {
+                const fileContents = fs_1.default.readFileSync(localSettingsPath, 'utf8');
+                fs_1.default.writeFileSync(SETTINGS_FILE, fileContents);
+                console.log(chalk_1.default?.cyan ? chalk_1.default.cyan(`Migrated settings.yaml to ${SETTINGS_FILE}`) : `Migrated settings.yaml to ${SETTINGS_FILE}`);
+            }
+            catch (error) {
+                console.error('Error migrating settings.yaml:', error);
+            }
+        }
+        else {
+            // Create default settings.yaml if it doesn't exist anywhere
+            const defaultSettings = {
+                projects: ['all'],
+                commands: ['all']
+            };
+            try {
+                const yamlStr = js_yaml_1.default.dump(defaultSettings);
+                fs_1.default.writeFileSync(SETTINGS_FILE, yamlStr);
+            }
+            catch (error) {
+                console.error('Error creating default settings.yaml:', error);
+            }
+            cachedSettings = defaultSettings;
+            return cachedSettings;
+        }
     }
     try {
-        const fileContents = fs_1.default.readFileSync(settingsPath, 'utf8');
+        const fileContents = fs_1.default.readFileSync(SETTINGS_FILE, 'utf8');
         const settings = js_yaml_1.default.load(fileContents);
         cachedSettings = {
             projects: settings.projects || ['all'],
@@ -36,7 +69,7 @@ function loadSettings() {
         return cachedSettings;
     }
     catch (error) {
-        console.error('Error loading settings.yaml:', error);
+        console.error(`Error loading ${SETTINGS_FILE}:`, error);
         process.exit(1);
     }
 }

package/dist/lib/utils.js

@@ -10,8 +10,9 @@ exports.convertADFToMarkdown = convertADFToMarkdown;
 const chalk_1 = __importDefault(require("chalk"));
 const mdast_util_from_adf_1 = require("mdast-util-from-adf");
 const mdast_util_to_markdown_1 = require("mdast-util-to-markdown");
+const auth_storage_1 = require("./auth-storage");
 /**
- * Validate required environment variables
+ * Validate required environment variables or stored credentials
  */
 function validateEnvVars() {
     const required = [
@@ -20,14 +21,11 @@ function validateEnvVars() {
         'JIRA_API_TOKEN',
     ];
     const missing = required.filter((key) => !process.env[key]);
-    if (missing.length > 0) {
-        console.error(chalk_1.default.red('✗ Missing required environment variables:\n'));
-        missing.forEach((key) => console.error(chalk_1.default.red(`  - ${key}`)));
-        console.log('\nPlease create a .env file with the following variables:');
-        console.log('  JIRA_HOST=https://your-domain.atlassian.net');
-        console.log('  JIRA_USER_EMAIL=your-email@example.com');
-        console.log('  JIRA_API_TOKEN=your-api-token');
-        console.log('\nGet your API token from: https://id.atlassian.com/manage-profile/security/api-tokens');
+    if (missing.length > 0 && !(0, auth_storage_1.hasCredentials)()) {
+        console.error(chalk_1.default.red('✗ Jira credentials not found.\n'));
+        console.log('Please run ' + chalk_1.default.cyan('jira-ai auth') + ' to set up your credentials.');
+        console.log('Alternatively, you can set the following environment variables:');
+        required.forEach((key) => console.log(`  - ${key}`));
         process.exit(1);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jira-ai",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "CLI tool for interacting with Atlassian Jira",
   "main": "dist/cli.js",
   "bin": {

package/src/cli.ts

@@ -12,17 +12,32 @@ import { runJqlCommand } from './commands/run-jql';
 import { updateDescriptionCommand } from './commands/update-description';
 import { addCommentCommand } from './commands/add-comment';
 import { aboutCommand } from './commands/about';
+import { authCommand } from './commands/auth';
 import { isCommandAllowed, getAllowedCommands } from './lib/settings';
 
 // Load environment variables
 dotenv.config();
 
-// Validate environment variables
-validateEnvVars();
+// Create CLI program
+const program = new Command();
+
+program
+  .name('jira-ai')
+  .description('CLI tool for interacting with Atlassian Jira')
+  .version('1.0.0');
+
+// Middleware to validate credentials for commands that need them
+const validateCredentials = () => {
+  validateEnvVars();
+};
 
-// Helper function to wrap commands with permission check
-function withPermission(commandName: string, commandFn: (...args: any[]) => Promise<void>) {
+// Helper function to wrap commands with permission check and credential validation
+function withPermission(commandName: string, commandFn: (...args: any[]) => Promise<void>, skipValidation = false) {
   return async (...args: any[]) => {
+    if (!skipValidation) {
+      validateCredentials();
+    }
+    
     if (!isCommandAllowed(commandName)) {
       console.error(chalk.red(`\n❌ Command '${commandName}' is not allowed.`));
       console.log(chalk.gray('Allowed commands: ' + getAllowedCommands().join(', ')));
@@ -33,13 +48,11 @@ function withPermission(commandName: string, commandFn: (...args: any[]) => Prom
   };
 }
 
-// Create CLI program
-const program = new Command();
-
+// Auth command (always allowed, skips validation)
 program
-  .name('jira-ai')
-  .description('CLI tool for interacting with Atlassian Jira')
-  .version('1.0.0');
+  .command('auth')
+  .description('Set up Jira authentication credentials')
+  .action(() => authCommand());
 
 // Me command
 program

package/src/commands/about.ts

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { getAllowedCommands, getAllowedProjects, isCommandAllowed } from '../lib/settings';
+import { getAllowedCommands, getAllowedProjects, isCommandAllowed, getSettingsPath } from '../lib/settings';
 
 interface CommandInfo {
   name: string;
@@ -91,7 +91,7 @@ export async function aboutCommand() {
   console.log(chalk.green('  jira-ai <command> --help\n'));
 
   console.log(chalk.bold('Configuration:'));
-  console.log('  Settings are managed in settings.yaml');
+  console.log(`  Settings file: ${chalk.cyan(getSettingsPath())}`);
   const allowedProjects = getAllowedProjects();
   console.log(`  - Projects: ${allowedProjects.includes('all') ? 'All allowed' : allowedProjects.join(', ')}`);
   console.log(`  - Commands: ${isAllAllowed ? 'All allowed' : allowedCommandsList.join(', ')}\n`);

package/src/commands/auth.ts

@@ -0,0 +1,81 @@
+import readline from 'readline';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createTemporaryClient } from '../lib/jira-client';
+import { saveCredentials } from '../lib/auth-storage';
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+function askSecret(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    // Hide input for secret (basic implementation)
+    const stdin = process.stdin;
+    process.stdout.write(question);
+    
+    // We can't easily hide characters in standard readline without some complex logic
+    // or external libraries. For now, we'll just use regular question but we'll 
+    // mention it's a secret.
+    rl.question('', (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+export async function authCommand(): Promise<void> {
+  console.log(chalk.cyan('\n--- Jira Authentication Setup ---\n'));
+
+  try {
+    const host = await ask('Jira URL (e.g., https://your-domain.atlassian.net): ');
+    if (!host) {
+      console.error(chalk.red('URL is required.'));
+      process.exit(1);
+    }
+
+    const email = await ask('Email: ');
+    if (!email) {
+      console.error(chalk.red('Email is required.'));
+      process.exit(1);
+    }
+
+    console.log(chalk.gray('Get your API token from: https://id.atlassian.com/manage-profile/security/api-tokens'));
+    const apiToken = await ask('API Token: ');
+    if (!apiToken) {
+      console.error(chalk.red('API Token is required.'));
+      process.exit(1);
+    }
+
+    const spinner = ora('Verifying credentials...').start();
+
+    try {
+      const tempClient = createTemporaryClient(host, email, apiToken);
+      const user = await tempClient.myself.getCurrentUser();
+
+      spinner.succeed(chalk.green('Authentication successful!'));
+      console.log(chalk.blue(`\nWelcome, ${user.displayName} (${user.emailAddress})`));
+
+      saveCredentials({ host, email, apiToken });
+      console.log(chalk.green('\nCredentials saved successfully to ~/.jira-ai/config.json'));
+      console.log(chalk.gray('These credentials will be used for future commands on this machine.'));
+    } catch (error: any) {
+      spinner.fail(chalk.red('Authentication failed.'));
+      console.error(chalk.red(`Error: ${error.message || 'Invalid credentials'}`));
+      if (error.response && error.response.status === 401) {
+        console.error(chalk.yellow('Hint: Check if your email and API token are correct.'));
+      }
+      process.exit(1);
+    } 
+  } finally {
+    rl.close();
+  }
+}

package/src/lib/auth-storage.ts

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export interface AuthCredentials {
+  host: string;
+  email: string;
+  apiToken: string;
+}
+
+const CONFIG_DIR = path.join(os.homedir(), '.jira-ai');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+/**
+ * Save credentials to local storage
+ */
+export function saveCredentials(creds: AuthCredentials): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(creds, null, 2), {
+    mode: 0o600, // Read/write for owner only
+  });
+}
+
+/**
+ * Load credentials from local storage
+ */
+export function loadCredentials(): AuthCredentials | null {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return null;
+  }
+
+  try {
+    const data = fs.readFileSync(CONFIG_FILE, 'utf8');
+    return JSON.parse(data) as AuthCredentials;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if credentials exist
+ */
+export function hasCredentials(): boolean {
+  return fs.existsSync(CONFIG_FILE);
+}
+
+/**
+ * Clear stored credentials
+ */
+export function clearCredentials(): void {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+  }
+}

package/src/lib/jira-client.ts

@@ -1,5 +1,6 @@
 import { Version3Client } from 'jira.js';
 import { convertADFToMarkdown } from './utils';
+import { loadCredentials } from './auth-storage';
 
 export interface UserInfo {
   accountId: string;
@@ -8,6 +9,7 @@ export interface UserInfo {
   active: boolean;
   timeZone: string;
 }
+// ... (rest of interfaces)
 
 export interface Project {
   id: string;
@@ -92,19 +94,55 @@ let jiraClient: Version3Client | null = null;
  */
 export function getJiraClient(): Version3Client {
   if (!jiraClient) {
-    jiraClient = new Version3Client({
-      host: process.env.JIRA_HOST!,
-      authentication: {
-        basic: {
-          email: process.env.JIRA_USER_EMAIL!,
-          apiToken: process.env.JIRA_API_TOKEN!,
+    const host = process.env.JIRA_HOST;
+    const email = process.env.JIRA_USER_EMAIL;
+    const apiToken = process.env.JIRA_API_TOKEN;
+
+    if (host && email && apiToken) {
+      jiraClient = new Version3Client({
+        host,
+        authentication: {
+          basic: {
+            email,
+            apiToken,
+          },
         },
-      },
-    });
+      });
+    } else {
+      const storedCreds = loadCredentials();
+      if (storedCreds) {
+        jiraClient = new Version3Client({
+          host: storedCreds.host,
+          authentication: {
+            basic: {
+              email: storedCreds.email,
+              apiToken: storedCreds.apiToken,
+            },
+          },
+        });
+      } else {
+        throw new Error('Jira credentials not found. Please set environment variables or run "jira-ai auth"');
+      }
+    }
   }
   return jiraClient;
 }
 
+/**
+ * Initialize a temporary Jira client for verification
+ */
+export function createTemporaryClient(host: string, email: string, apiToken: string): Version3Client {
+  return new Version3Client({
+    host,
+    authentication: {
+      basic: {
+        email,
+        apiToken,
+      },
+    },
+  });
+}
+
 /**
  * Get current user information
  */

package/src/lib/settings.ts

@@ -1,32 +1,64 @@
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 import yaml from 'js-yaml';
+import chalk from 'chalk';
 
 export interface Settings {
   projects: string[];
   commands: string[];
 }
 
+const CONFIG_DIR = path.join(os.homedir(), '.jira-ai');
+const SETTINGS_FILE = path.join(CONFIG_DIR, 'settings.yaml');
+
 let cachedSettings: Settings | null = null;
 
+export function getSettingsPath(): string {
+  return SETTINGS_FILE;
+}
+
 export function loadSettings(): Settings {
   if (cachedSettings) {
     return cachedSettings;
   }
 
-  const settingsPath = path.join(process.cwd(), 'settings.yaml');
+  // Ensure config directory exists
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
 
-  if (!fs.existsSync(settingsPath)) {
-    console.warn('Warning: settings.yaml not found. Using default settings (all allowed).');
-    cachedSettings = {
-      projects: ['all'],
-      commands: ['all']
-    };
-    return cachedSettings;
+  if (!fs.existsSync(SETTINGS_FILE)) {
+    // Check if settings.yaml exists in current working directory (migration/backward compatibility)
+    const localSettingsPath = path.join(process.cwd(), 'settings.yaml');
+    if (fs.existsSync(localSettingsPath)) {
+      try {
+        const fileContents = fs.readFileSync(localSettingsPath, 'utf8');
+        fs.writeFileSync(SETTINGS_FILE, fileContents);
+        console.log(chalk?.cyan ? chalk.cyan(`Migrated settings.yaml to ${SETTINGS_FILE}`) : `Migrated settings.yaml to ${SETTINGS_FILE}`);
+      } catch (error) {
+        console.error('Error migrating settings.yaml:', error);
+      }
+    } else {
+      // Create default settings.yaml if it doesn't exist anywhere
+      const defaultSettings: Settings = {
+        projects: ['all'],
+        commands: ['all']
+      };
+      try {
+        const yamlStr = yaml.dump(defaultSettings);
+        fs.writeFileSync(SETTINGS_FILE, yamlStr);
+      } catch (error) {
+        console.error('Error creating default settings.yaml:', error);
+      }
+      
+      cachedSettings = defaultSettings;
+      return cachedSettings;
+    }
   }
 
   try {
-    const fileContents = fs.readFileSync(settingsPath, 'utf8');
+    const fileContents = fs.readFileSync(SETTINGS_FILE, 'utf8');
     const settings = yaml.load(fileContents) as Settings;
 
     cachedSettings = {
@@ -36,7 +68,7 @@ export function loadSettings(): Settings {
 
     return cachedSettings;
   } catch (error) {
-    console.error('Error loading settings.yaml:', error);
+    console.error(`Error loading ${SETTINGS_FILE}:`, error);
     process.exit(1);
   }
 }

package/src/lib/utils.ts

@@ -1,9 +1,10 @@
 import chalk from 'chalk';
 import { fromADF } from 'mdast-util-from-adf';
 import { toMarkdown } from 'mdast-util-to-markdown';
+import { hasCredentials } from './auth-storage';
 
 /**
- * Validate required environment variables
+ * Validate required environment variables or stored credentials
  */
 export function validateEnvVars(): void {
   const required = [
@@ -14,14 +15,11 @@ export function validateEnvVars(): void {
 
   const missing = required.filter((key) => !process.env[key]);
 
-  if (missing.length > 0) {
-    console.error(chalk.red('✗ Missing required environment variables:\n'));
-    missing.forEach((key) => console.error(chalk.red(`  - ${key}`)));
-    console.log('\nPlease create a .env file with the following variables:');
-    console.log('  JIRA_HOST=https://your-domain.atlassian.net');
-    console.log('  JIRA_USER_EMAIL=your-email@example.com');
-    console.log('  JIRA_API_TOKEN=your-api-token');
-    console.log('\nGet your API token from: https://id.atlassian.com/manage-profile/security/api-tokens');
+  if (missing.length > 0 && !hasCredentials()) {
+    console.error(chalk.red('✗ Jira credentials not found.\n'));
+    console.log('Please run ' + chalk.cyan('jira-ai auth') + ' to set up your credentials.');
+    console.log('Alternatively, you can set the following environment variables:');
+    required.forEach((key) => console.log(`  - ${key}`));
     process.exit(1);
   }
 }

package/tests/auth-storage.test.ts

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Mock os.homedir()
+const tempDir = path.join(__dirname, 'temp-home');
+const homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tempDir);
+
+// Now import the module under test
+import { saveCredentials, loadCredentials, hasCredentials, clearCredentials } from '../src/lib/auth-storage';
+
+describe('auth-storage', () => {
+  beforeAll(() => {
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir);
+    }
+  });
+
+  afterAll(() => {
+    homedirSpy.mockRestore();
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  beforeEach(() => {
+    clearCredentials();
+  });
+// ...
+
+  test('should save and load credentials', () => {
+    const creds = {
+      host: 'https://test.atlassian.net',
+      email: 'test@example.com',
+      apiToken: 'token123'
+    };
+
+    saveCredentials(creds);
+    expect(hasCredentials()).toBe(true);
+
+    const loaded = loadCredentials();
+    expect(loaded).toEqual(creds);
+  });
+
+  test('should return null if no credentials exist', () => {
+    expect(loadCredentials()).toBeNull();
+    expect(hasCredentials()).toBe(false);
+  });
+
+  test('should clear credentials', () => {
+    const creds = {
+      host: 'https://test.atlassian.net',
+      email: 'test@example.com',
+      apiToken: 'token123'
+    };
+
+    saveCredentials(creds);
+    expect(hasCredentials()).toBe(true);
+
+    clearCredentials();
+    expect(hasCredentials()).toBe(false);
+    expect(loadCredentials()).toBeNull();
+  });
+});

package/to-do.md

@@ -3,7 +3,6 @@
 - edit task description from .md file - done
 - add comment from .md file - done 
 - get all parent and nested features - done 
-
+- auth - done
 
 - create task from {with-template} using parent
-- auth