@relipa/ai-flow-kit 0.0.9-beta.1 → 0.1.0-beta.0

package/scripts/hooks/session-stop.js

@@ -1,122 +1,122 @@
-#!/usr/bin/env node
-/**
- * SessionStop hook for ai-flow-kit
- * - Records session telemetry: model, token usage, prompt summary
- * - Prints a token usage summary from checkpoints.json
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-function loadTelemetry() {
-    try { return require('../telemetry/record'); } catch (_) {}
-    return { record: () => {} };
-}
-
-function loadTelemetryConfig() {
-    try { return require('../telemetry/config'); } catch (_) {}
-    return { loadConfig: () => ({}) };
-}
-
-const { record } = loadTelemetry();
-const { loadConfig } = loadTelemetryConfig();
-
-const GATE_LABELS = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
-
-let raw = '';
-process.stdin.setEncoding('utf-8');
-process.stdin.on('data', chunk => { raw += chunk; });
-process.stdin.on('end', () => {
-    let hookData = {};
-    try { hookData = JSON.parse(raw || '{}'); } catch (_) {}
-
-    const cfg = loadConfig();
-    let model = '';
-    let tokens_input = 0;
-    let tokens_output = 0;
-    let prompt_summary = '';
-
-    const transcriptPath = hookData.transcript_path;
-    if (transcriptPath && fs.existsSync(transcriptPath)) {
-        try {
-            const lines = fs.readFileSync(transcriptPath, 'utf-8').split('\n');
-            let firstUserDone = false;
-            for (const line of lines) {
-                if (!line.trim()) continue;
-                let entry;
-                try { entry = JSON.parse(line); } catch (_) { continue; }
-
-                if (entry.type === 'user' && !firstUserDone) {
-                    const content = entry.message && entry.message.content;
-                    if (Array.isArray(content)) {
-                        const block = content.find(b => b.type === 'text');
-                        if (block && block.text) prompt_summary = block.text.substring(0, 200);
-                    } else if (typeof content === 'string') {
-                        prompt_summary = content.substring(0, 200);
-                    }
-                    firstUserDone = true;
-                }
-
-                if (entry.type === 'assistant') {
-                    const msg = entry.message || {};
-                    if (msg.usage) {
-                        tokens_input  += msg.usage.input_tokens  || 0;
-                        tokens_output += msg.usage.output_tokens || 0;
-                    }
-                    if (!model && msg.model) model = msg.model;
-                }
-            }
-        } catch (_) {}
-    }
-
-    record('session.stop', {
-        ai_email: cfg.email || '',
-        model: model || undefined,
-        tokens_input:  tokens_input  || undefined,
-        tokens_output: tokens_output || undefined,
-        prompt_summary: prompt_summary || undefined,
-    });
-
-    // ── Token usage summary from checkpoints ──────────────────
-    const projectRoot = path.resolve(__dirname, '..', '..');
-    const contextFile = path.join(projectRoot, '.aiflow', 'context', 'current.json');
-    const tasksDir    = path.join(projectRoot, '.aiflow', 'tasks');
-
-    try {
-        if (!fs.existsSync(contextFile)) process.exit(0);
-        const ctx = JSON.parse(fs.readFileSync(contextFile, 'utf-8'));
-        const ticketId = ctx && ctx.taskId;
-        if (!ticketId) process.exit(0);
-
-        const checkpointPath = path.join(tasksDir, ticketId, 'checkpoints.json');
-        if (!fs.existsSync(checkpointPath)) process.exit(0);
-
-        const data = JSON.parse(fs.readFileSync(checkpointPath, 'utf-8'));
-        const checkpoints = data.checkpoints || [];
-        if (checkpoints.length === 0) process.exit(0);
-
-        const gateTokens = {};
-        for (const cp of checkpoints) {
-            const g = cp.gate;
-            if (!gateTokens[g] || cp.tokens > gateTokens[g]) {
-                gateTokens[g] = cp.tokens;
-            }
-        }
-
-        const gates = Object.keys(gateTokens).sort();
-        const total  = gates.reduce((sum, g) => sum + gateTokens[g], 0);
-
-        process.stderr.write('\n[aiflow] Token usage this session:\n');
-        for (const g of gates) {
-            const label = GATE_LABELS[parseInt(g)] || `Gate ${g}`;
-            const t     = gateTokens[g];
-            const bar   = '█'.repeat(Math.round((t / total) * 20)).padEnd(20, '░');
-            const pct   = Math.round((t / total) * 100);
-            process.stderr.write(`[aiflow]   Gate ${g}  ${label.padEnd(8)}  ~${t.toLocaleString().padStart(6)}  ${bar}  ${pct}%\n`);
-        }
-        process.stderr.write(`[aiflow]   Total estimated: ~${total.toLocaleString()} tokens\n\n`);
-    } catch (_) {}
-
-    process.exit(0);
-});
+#!/usr/bin/env node
+/**
+ * SessionStop hook for ai-flow-kit
+ * - Records session telemetry: model, token usage, prompt summary
+ * - Prints a token usage summary from checkpoints.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function loadTelemetry() {
+    try { return require('../telemetry/record'); } catch (_) {}
+    return { record: () => {} };
+}
+
+function loadTelemetryConfig() {
+    try { return require('../telemetry/config'); } catch (_) {}
+    return { loadConfig: () => ({}) };
+}
+
+const { record } = loadTelemetry();
+const { loadConfig } = loadTelemetryConfig();
+
+const GATE_LABELS = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => { raw += chunk; });
+process.stdin.on('end', () => {
+    let hookData = {};
+    try { hookData = JSON.parse(raw || '{}'); } catch (_) {}
+
+    const cfg = loadConfig();
+    let model = '';
+    let tokens_input = 0;
+    let tokens_output = 0;
+    let prompt_summary = '';
+
+    const transcriptPath = hookData.transcript_path;
+    if (transcriptPath && fs.existsSync(transcriptPath)) {
+        try {
+            const lines = fs.readFileSync(transcriptPath, 'utf-8').split('\n');
+            let firstUserDone = false;
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                let entry;
+                try { entry = JSON.parse(line); } catch (_) { continue; }
+
+                if (entry.type === 'user' && !firstUserDone) {
+                    const content = entry.message && entry.message.content;
+                    if (Array.isArray(content)) {
+                        const block = content.find(b => b.type === 'text');
+                        if (block && block.text) prompt_summary = block.text.substring(0, 200);
+                    } else if (typeof content === 'string') {
+                        prompt_summary = content.substring(0, 200);
+                    }
+                    firstUserDone = true;
+                }
+
+                if (entry.type === 'assistant') {
+                    const msg = entry.message || {};
+                    if (msg.usage) {
+                        tokens_input  += msg.usage.input_tokens  || 0;
+                        tokens_output += msg.usage.output_tokens || 0;
+                    }
+                    if (!model && msg.model) model = msg.model;
+                }
+            }
+        } catch (_) {}
+    }
+
+    record('session.stop', {
+        ai_email: cfg.email || '',
+        model: model || undefined,
+        tokens_input:  tokens_input  || undefined,
+        tokens_output: tokens_output || undefined,
+        prompt_summary: prompt_summary || undefined,
+    });
+
+    // ── Token usage summary from checkpoints ──────────────────
+    const projectRoot = path.resolve(__dirname, '..', '..');
+    const contextFile = path.join(projectRoot, '.aiflow', 'context', 'current.json');
+    const tasksDir    = path.join(projectRoot, '.aiflow', 'tasks');
+
+    try {
+        if (!fs.existsSync(contextFile)) process.exit(0);
+        const ctx = JSON.parse(fs.readFileSync(contextFile, 'utf-8'));
+        const ticketId = ctx && ctx.taskId;
+        if (!ticketId) process.exit(0);
+
+        const checkpointPath = path.join(tasksDir, ticketId, 'checkpoints.json');
+        if (!fs.existsSync(checkpointPath)) process.exit(0);
+
+        const data = JSON.parse(fs.readFileSync(checkpointPath, 'utf-8'));
+        const checkpoints = data.checkpoints || [];
+        if (checkpoints.length === 0) process.exit(0);
+
+        const gateTokens = {};
+        for (const cp of checkpoints) {
+            const g = cp.gate;
+            if (!gateTokens[g] || cp.tokens > gateTokens[g]) {
+                gateTokens[g] = cp.tokens;
+            }
+        }
+
+        const gates = Object.keys(gateTokens).sort();
+        const total  = gates.reduce((sum, g) => sum + gateTokens[g], 0);
+
+        process.stderr.write('\n[aiflow] Token usage this session:\n');
+        for (const g of gates) {
+            const label = GATE_LABELS[parseInt(g)] || `Gate ${g}`;
+            const t     = gateTokens[g];
+            const bar   = '█'.repeat(Math.round((t / total) * 20)).padEnd(20, '░');
+            const pct   = Math.round((t / total) * 100);
+            process.stderr.write(`[aiflow]   Gate ${g}  ${label.padEnd(8)}  ~${t.toLocaleString().padStart(6)}  ${bar}  ${pct}%\n`);
+        }
+        process.stderr.write(`[aiflow]   Total estimated: ~${total.toLocaleString()} tokens\n\n`);
+    } catch (_) {}
+
+    process.exit(0);
+});

package/scripts/init.js

@@ -903,9 +903,22 @@ async function init(options) {
 
         // ── Auto-detect or prompt for framework if not supplied ──────
         if (frameworks.length === 0) {
+            const stateFilePath = path.join(aiflowDir, 'state.json');
+            let previousFrameworks = [];
+            if (await fs.pathExists(stateFilePath)) {
+                const savedState = await fs.readJson(stateFilePath);
+                previousFrameworks = savedState.frameworks || [];
+            }
+
             const detected = await detectFramework(projectDir);
             const hint = chalk.gray('  Space to select/unselect · Enter to confirm · Leave empty to skip');
-            if (detected) {
+            if (previousFrameworks.length > 0) {
+                const labels = previousFrameworks
+                    .map(v => FRAMEWORK_CHOICES.find(c => c.value === v)?.name || v)
+                    .join(', ');
+                console.log(chalk.cyan(`\n  Previously selected: ${chalk.bold(labels)}`));
+                console.log(hint);
+            } else if (detected) {
                 const label = FRAMEWORK_CHOICES.find(c => c.value === detected)?.name || detected;
                 console.log(chalk.cyan(`\n  Detected framework: ${chalk.bold(label)}`));
                 console.log(hint);
@@ -917,7 +930,9 @@ async function init(options) {
                 message: 'Select framework(s):',
                 choices: FRAMEWORK_CHOICES.map(c => ({
                     ...c,
-                    checked: c.value === detected,
+                    checked: previousFrameworks.length > 0
+                        ? previousFrameworks.includes(c.value)
+                        : c.value === detected,
                 })),
             });
             frameworks = chosen;

package/scripts/link-resolver.js

@@ -0,0 +1,179 @@
+'use strict';
+const https = require('https');
+const chalk = require('chalk');
+
+const BACKLOG_RE = /https?:\/\/([\w.-]+\.backlog(?:tool)?\.com)\/view\/([A-Z][A-Z0-9_]+-\d+)(?:#comment-(\d+))?/i;
+const JIRA_RE = /https?:\/\/([\w.-]+\.atlassian\.net)\/browse\/([A-Z][A-Z0-9_]+-\d+)/i;
+const JIRA_COMMENT_RE = /[?&]focusedCommentId=(\d+)/;
+const URL_RE = /https?:\/\/[^\s\)\]"<>]+/g;
+
+const MAX_AUTO_LINKS = 5;
+
+function classifyLink(url) {
+  const bm = url.match(BACKLOG_RE);
+  if (bm) {
+    const [, domain, ticketId, commentId] = bm;
+    return { adapter: 'backlog', domain, ticketId, commentId: commentId || null, isComment: !!commentId };
+  }
+  const jm = url.match(JIRA_RE);
+  if (jm) {
+    const [, domain, ticketId] = jm;
+    const cm = url.match(JIRA_COMMENT_RE);
+    const commentId = cm ? cm[1] : null;
+    return { adapter: 'jira', domain, ticketId, commentId, isComment: !!commentId };
+  }
+  return null;
+}
+
+function scanLinks(text) {
+  const found = [];
+  let m;
+  URL_RE.lastIndex = 0;
+  while ((m = URL_RE.exec(text)) !== null) {
+    const classified = classifyLink(m[0]);
+    if (classified) found.push({ url: m[0], ...classified });
+  }
+  return found;
+}
+
+function httpsGet(url, headers) {
+  return new Promise((resolve, reject) => {
+    const opts = headers ? { headers } : {};
+    https.get(url, opts, (res) => {
+      let data = '';
+      res.on('data', chunk => (data += chunk));
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(new Error('Invalid JSON from API')); }
+      });
+    }).on('error', reject);
+  });
+}
+
+async function fetchBacklogTicket(domain, apiKey, ticketId) {
+  const issue = await httpsGet(`https://${domain}/api/v2/issues/${ticketId}?apiKey=${apiKey}`);
+  return {
+    sourceType: 'ticket',
+    sourceUrl: `https://${domain}/view/${ticketId}`,
+    ticketId,
+    title: issue.summary || '',
+    description: (issue.description || '').substring(0, 2000),
+  };
+}
+
+async function fetchBacklogComment(domain, apiKey, ticketId, commentId) {
+  const comments = await httpsGet(
+    `https://${domain}/api/v2/issues/${ticketId}/comments?apiKey=${apiKey}&count=100&order=asc`
+  );
+  const comment = (comments || []).find(c => String(c.id) === String(commentId));
+  if (!comment) throw new Error(`Comment ${commentId} not found in ${ticketId}`);
+  const date = comment.created ? new Date(comment.created).toLocaleDateString('vi-VN') : '';
+  return {
+    sourceType: 'comment',
+    sourceUrl: `https://${domain}/view/${ticketId}#comment-${commentId}`,
+    ticketId,
+    commentId: String(commentId),
+    author: comment.createdUser?.name || 'Unknown',
+    date,
+    content: (comment.content || '').substring(0, 2000),
+  };
+}
+
+function jiraAuth(email, token) {
+  return `Basic ${Buffer.from(`${email}:${token}`).toString('base64')}`;
+}
+
+function extractJiraText(descField) {
+  if (!descField) return '';
+  return (descField.content || [])
+    .map(block => (block.content || []).map(c => c.text || '').join(''))
+    .join('\n');
+}
+
+async function fetchJiraTicket(domain, email, token, ticketId) {
+  const issue = await httpsGet(
+    `https://${domain}/rest/api/3/issue/${ticketId}`,
+    { Authorization: jiraAuth(email, token), Accept: 'application/json' }
+  );
+  const fields = issue.fields || {};
+  return {
+    sourceType: 'ticket',
+    sourceUrl: `https://${domain}/browse/${ticketId}`,
+    ticketId,
+    title: fields.summary || '',
+    description: extractJiraText(fields.description).substring(0, 2000),
+  };
+}
+
+async function fetchJiraComment(domain, email, token, ticketId, commentId) {
+  const data = await httpsGet(
+    `https://${domain}/rest/api/3/issue/${ticketId}/comment/${commentId}`,
+    { Authorization: jiraAuth(email, token), Accept: 'application/json' }
+  );
+  const date = data.created ? new Date(data.created).toLocaleDateString('vi-VN') : '';
+  return {
+    sourceType: 'comment',
+    sourceUrl: `https://${domain}/browse/${ticketId}?focusedCommentId=${commentId}`,
+    ticketId,
+    commentId: String(commentId),
+    author: data.author?.displayName || 'Unknown',
+    date,
+    content: extractJiraText(data.body).substring(0, 2000),
+  };
+}
+
+async function fetchLink(url, credentials = {}, alreadyLoadedIds = []) {
+  const classified = classifyLink(url);
+  if (!classified) return null;
+
+  const { adapter, domain, ticketId, commentId, isComment } = classified;
+  const dedupeKey = ticketId + (commentId ? '#' + commentId : '');
+  if (alreadyLoadedIds.includes(dedupeKey) || alreadyLoadedIds.includes(ticketId)) return null;
+
+  if (adapter === 'backlog') {
+    const apiKey = credentials.BACKLOG_API_KEY;
+    if (!apiKey) throw new Error('BACKLOG_API_KEY not set');
+    if (isComment) return await fetchBacklogComment(domain, apiKey, ticketId, commentId);
+    return await fetchBacklogTicket(domain, apiKey, ticketId);
+  }
+
+  if (adapter === 'jira') {
+    const email = credentials.JIRA_EMAIL;
+    const token = credentials.JIRA_API_TOKEN;
+    if (!email || !token) throw new Error('JIRA_EMAIL or JIRA_API_TOKEN not set');
+    if (isComment) return await fetchJiraComment(domain, email, token, ticketId, commentId);
+    return await fetchJiraTicket(domain, email, token, ticketId);
+  }
+
+  return null;
+}
+
+async function resolveLinks(description, credentials = {}, alreadyLoadedIds = []) {
+  const links = scanLinks(description).slice(0, MAX_AUTO_LINKS);
+  if (!links.length) return [];
+
+  const results = [];
+  const seen = [...alreadyLoadedIds];
+
+  for (const link of links) {
+    const dedupeKey = link.ticketId + (link.commentId ? '#' + link.commentId : '');
+    if (seen.includes(dedupeKey) || seen.includes(link.ticketId)) continue;
+    try {
+      const item = await fetchLink(link.url, credentials, seen);
+      if (item) {
+        results.push(item);
+        seen.push(dedupeKey);
+        console.log(chalk.gray(`  ✓ Auto-resolved: ${link.ticketId}${link.commentId ? '#' + link.commentId : ''}`));
+      }
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Could not resolve ${link.url}: ${err.message}`));
+    }
+  }
+  return results;
+}
+
+module.exports = { classifyLink, scanLinks, fetchBacklogTicket, fetchBacklogComment, fetchJiraTicket, fetchJiraComment, fetchLink, resolveLinks };

package/scripts/use.js

@@ -14,7 +14,12 @@ const CONTEXT_DIR = path.join(PROJECT_DIR, ".aiflow", "context");
 // Entry point
 // ──────────────────────────────────────────────────────────────
 
-module.exports = async function use(target, options = {}) {
+const useCommand = async function use(targets, options = {}) {
+  // Normalize: accept string (legacy) or array (new multi-target)
+  const targetList = Array.isArray(targets) ? targets.filter(Boolean) : (targets ? [targets] : []);
+  const primaryTarget = targetList[0] || null;
+  const supplementaryTargets = targetList.slice(1);
+
   if (!(await fs.pathExists(STATE_FILE))) {
     console.log(
       chalk.red("Project is not initialized. Run `aiflow init` first."),
@@ -36,28 +41,30 @@ module.exports = async function use(target, options = {}) {
   }
 
   // ── No target → version switcher ──
-  if (!target) {
+  if (!primaryTarget) {
     return await switchVersion();
   }
 
   // ── Detect target type and dispatch ──
-  if (isVersion(target)) {
-    return await switchVersion(target);
+  if (isVersion(primaryTarget)) {
+    return await switchVersion(primaryTarget);
   }
 
-  if (isTicketId(target)) {
+  if (isTicketId(primaryTarget)) {
     const adapter = await resolveTicketAdapter();
-    if (adapter === "jira") return await loadFromJira(target, options);
-    return await loadFromBacklog(target, options);
+    if (adapter === "jira") await loadFromJira(primaryTarget, options);
+    else await loadFromBacklog(primaryTarget, options);
+    return await enrichWithSupplementary(supplementaryTargets);
   }
 
-  if (isBacklogUrl(target)) {
-    const id = extractBacklogId(target);
-    return await loadFromBacklog(id, options);
+  if (isBacklogUrl(primaryTarget)) {
+    const id = extractBacklogId(primaryTarget);
+    await loadFromBacklog(id, options);
+    return await enrichWithSupplementary(supplementaryTargets);
   }
 
   // ── Fallback: try Backlog then manual ──
-  console.log(chalk.yellow(`Cannot detect format for: ${target}`));
+  console.log(chalk.yellow(`Cannot detect format for: ${primaryTarget}`));
   console.log(
     chalk.gray("Supported: PROJ-33, APP-123, version number, --manual"),
   );
@@ -1054,3 +1061,102 @@ async function suggestNextStep() {
   );
   console.log();
 }
+
+async function loadTargetAsSupplementaryContext(target, creds, alreadyIds) {
+  if (!target) return null;
+
+  // File path (not a ticket ID, not a backlog URL)
+  if (!isTicketId(target) && !isBacklogUrl(target)) {
+    try {
+      const raw = await fs.readFile(target, 'utf-8');
+      return {
+        sourceType: 'file',
+        sourcePath: target,
+        title: path.basename(target),
+        content: raw.substring(0, 3000),
+      };
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Could not read file: ${target}`));
+      return null;
+    }
+  }
+
+  const issueKey = isBacklogUrl(target) ? extractBacklogId(target) : target;
+  if (!issueKey || alreadyIds.includes(issueKey)) return null;
+
+  const adapter = await resolveTicketAdapter();
+
+  try {
+    if (adapter === 'jira') {
+      const token = creds.JIRA_API_TOKEN;
+      const email = creds.JIRA_EMAIL;
+      const domain = creds.JIRA_DOMAIN;
+      if (!token || !email || !domain) return null;
+      const issue = await fetchJiraIssue(domain, email, token, issueKey);
+      const fields = issue.fields || {};
+      const desc = (fields.description?.content || [])
+        .map(b => (b.content || []).map(c => c.text || '').join('')).join('\n');
+      return {
+        sourceType: 'ticket',
+        sourceUrl: `https://${domain}.atlassian.net/browse/${issueKey}`,
+        ticketId: issueKey,
+        title: fields.summary || '',
+        description: desc.substring(0, 2000),
+      };
+    }
+    const apiKey = creds.BACKLOG_API_KEY;
+    const spaceKey = creds.BACKLOG_SPACE_KEY || creds.BACKLOG_DOMAIN;
+    if (!apiKey || !spaceKey) return null;
+    const domain = spaceKey.includes('.') ? spaceKey : `${spaceKey}.backlog.com`;
+    const issue = await fetchBacklogIssue(domain, apiKey, issueKey);
+    return {
+      sourceType: 'ticket',
+      sourceUrl: `https://${domain}/view/${issueKey}`,
+      ticketId: issueKey,
+      title: issue.summary || '',
+      description: (issue.description || '').substring(0, 2000),
+    };
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Could not load supplementary ${issueKey}: ${err.message}`));
+    return null;
+  }
+}
+
+async function enrichWithSupplementary(supplementaryTargets) {
+  const currentFile = path.join(CONTEXT_DIR, 'current.json');
+  if (!(await fs.pathExists(currentFile))) return;
+
+  const ctx = await fs.readJson(currentFile).catch(() => null);
+  if (!ctx) return;
+
+  const creds = await loadCredentials();
+  const supplementary = [];
+  const alreadyIds = [ctx.taskId].filter(Boolean);
+
+  for (const t of supplementaryTargets) {
+    const sc = await loadTargetAsSupplementaryContext(t, creds, alreadyIds);
+    if (sc) {
+      supplementary.push(sc);
+      if (sc.ticketId) alreadyIds.push(sc.ticketId);
+    }
+  }
+
+  if (ctx.description) {
+    const { resolveLinks } = require('./link-resolver');
+    const linked = await resolveLinks(ctx.description, creds, alreadyIds);
+    supplementary.push(...linked);
+  }
+
+  if (supplementary.length > 0) {
+    ctx.supplementaryContext = supplementary;
+    await fs.writeJson(currentFile, ctx, { spaces: 2 });
+    const histFile = path.join(CONTEXT_DIR, 'history', `${ctx.taskId || 'manual'}.json`);
+    if (await fs.pathExists(path.dirname(histFile))) {
+      await fs.writeJson(histFile, ctx, { spaces: 2 });
+    }
+    console.log(chalk.green(`  ✓ ${supplementary.length} supplementary context(s) linked`));
+  }
+}
+
+module.exports = useCommand;
+module.exports.loadCredentials = loadCredentials;