qatools-cli 1.0.0

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "qatools-cli",
+  "version": "1.0.0",
+  "description": "CLI for QA Tools - read test sessions, upload Claude analysis",
+  "bin": {
+    "qatools": "./qatools.js"
+  },
+  "files": ["qatools.js"],
+  "keywords": ["qa", "testing", "claude", "ai", "test-management"],
+  "license": "MIT",
+  "dependencies": {
+    "firebase": "^11.0.0",
+    "commander": "^12.0.0"
+  }
+}

package/qatools.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+
+const { program } = require("commander");
+const { initializeApp } = require("firebase/app");
+const { getAuth, signInWithEmailAndPassword, signInWithCustomToken } = require("firebase/auth");
+const { getFunctions, httpsCallable, connectFunctionsEmulator } = require("firebase/functions");
+const fs = require("fs");
+const path = require("path");
+const http = require("http");
+
+const firebaseConfig = {
+  projectId: "qatools-app",
+  appId: "1:818706206429:web:647fe512fdba662cb4d534",
+  storageBucket: "qatools-app.firebasestorage.app",
+  apiKey: "AIzaSyAh-wQgQ7g0aEDnriEPmpS13VqeyKznFHw",
+  authDomain: "qatools-app.firebaseapp.com",
+  messagingSenderId: "818706206429",
+};
+
+const app = initializeApp(firebaseConfig);
+const auth = getAuth(app);
+const functions = getFunctions(app);
+
+// Load credentials from ~/.qatools or env vars
+function getCredentials() {
+  const configPath = path.join(process.env.HOME || process.env.USERPROFILE, ".qatools");
+  if (fs.existsSync(configPath)) {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  }
+  if (process.env.QATOOLS_EMAIL && process.env.QATOOLS_PASSWORD) {
+    return { email: process.env.QATOOLS_EMAIL, password: process.env.QATOOLS_PASSWORD };
+  }
+  return null;
+}
+
+async function authenticate(options) {
+  const creds = getCredentials();
+  const email = options.email || creds?.email;
+  const password = options.password || creds?.password;
+  const refreshToken = creds?.refreshToken;
+
+  if (refreshToken) {
+    try {
+      // Exchange refresh token for a new ID token, then sign in
+      const res = await fetch(`https://securetoken.googleapis.com/v1/token?key=${firebaseConfig.apiKey}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: `grant_type=refresh_token&refresh_token=${refreshToken}`,
+      });
+      const data = await res.json();
+      if (!data.id_token) throw new Error("Refresh failed");
+      // Use the auth emulator approach: sign in with custom token from server
+      // Actually we need to use signInWithCustomToken, so mint one
+      const mintRes = await fetch(`https://us-central1-qatools-app.cloudfunctions.net/mintCliToken`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${data.id_token}` },
+        body: JSON.stringify({ data: {} }),
+      });
+      const mintData = await mintRes.json();
+      if (mintData.result?.customToken) {
+        await signInWithCustomToken(auth, mintData.result.customToken);
+        return;
+      }
+      throw new Error("Mint failed");
+    } catch (e) {
+      console.error("Google token refresh failed:", e.message, "\nRun 'qatools login --google' again.");
+      process.exit(1);
+    }
+  }
+
+  if (!email || !password) {
+    console.error("Error: No credentials. Run 'qatools login --google' or 'qatools login -e <email> -p <password>'");
+    process.exit(1);
+  }
+  try {
+    await signInWithEmailAndPassword(auth, email, password);
+  } catch (e) {
+    console.error("Authentication failed:", e.message);
+    process.exit(1);
+  }
+}
+
+program
+  .name("qatools")
+  .description("CLI for QA Tools")
+  .version("1.0.0");
+
+program
+  .command("upload-analysis")
+  .description("Upload a Claude analysis JSON to a test session")
+  .requiredOption("-s, --session <id>", "Test session ID")
+  .requiredOption("-f, --file <path>", "Path to analysis JSON file")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+
+    const filePath = path.resolve(options.file);
+    if (!fs.existsSync(filePath)) {
+      console.error(`File not found: ${filePath}`);
+      process.exit(1);
+    }
+
+    const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const analysisArray = data.analysis || [data];
+    const backlogUpdates = data.backlogUpdates || {};
+
+    console.log(`Uploading ${analysisArray.length} analysis/analyses to session ${options.session}...`);
+
+    const uploadAnalysis = httpsCallable(functions, "uploadAnalysis");
+    try {
+      const result = await uploadAnalysis({
+        sessionId: options.session,
+        analysis: analysisArray,
+        backlogUpdates,
+      });
+      console.log("Success!");
+      console.log(`  Analyses on session: ${result.data.analysesCount}`);
+      console.log(`  Backlog items updated: ${result.data.backlogItemsUpdated}`);
+    } catch (e) {
+      console.error("Upload failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("read-session")
+  .description("Read a test session with template and backlog details")
+  .requiredOption("-s, --session <id>", "Test session ID")
+  .option("-o, --output <path>", "Output file (default: stdout)")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+
+    console.error(`Reading session ${options.session}...`);
+
+    const readSession = httpsCallable(functions, "readSession");
+    try {
+      const result = await readSession({ sessionId: options.session });
+      const json = JSON.stringify(result.data, null, 2);
+      if (options.output) {
+        fs.writeFileSync(path.resolve(options.output), json);
+        console.error(`Written to ${options.output}`);
+      } else {
+        console.log(json);
+      }
+    } catch (e) {
+      console.error("Read failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("setup")
+  .description("Select default project (login first with 'qatools login')")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    console.log("Fetching your projects...\n");
+
+    const listProjects = httpsCallable(functions, "listProjects");
+    const result = await listProjects({});
+    const projects = result.data.projects;
+
+    if (projects.length === 0) {
+      console.error("No projects found for this account.");
+      process.exit(1);
+    }
+
+    console.log("Your projects:");
+    projects.forEach((p, i) => console.log(`  ${i + 1}. ${p.name} ${p.claudeEnabled ? '🤖' : ''} (${p.id})`));
+
+    // Use readline for selection
+    const readline = require("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise(resolve => rl.question(`\nSelect project (1-${projects.length}): `, resolve));
+    rl.close();
+
+    const idx = parseInt(answer, 10) - 1;
+    if (idx < 0 || idx >= projects.length) {
+      console.error("Invalid selection.");
+      process.exit(1);
+    }
+
+    const selected = projects[idx];
+    const configPath = path.join(process.env.HOME || process.env.USERPROFILE, ".qatools");
+    // Preserve existing credentials
+    let existing = {};
+    if (fs.existsSync(configPath)) {
+      try { existing = JSON.parse(fs.readFileSync(configPath, "utf-8")); } catch {}
+    }
+    const config = { ...existing, projectId: selected.id, projectName: selected.name };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(`\nSaved! Default project: ${selected.name} (${selected.id})`);
+    console.log(`Config: ${configPath}`);
+    process.exit(0);
+  });
+
+program
+  .command("pending")
+  .description("List test sessions awaiting Claude analysis")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    const creds = getCredentials();
+    const projectId = creds?.projectId;
+
+    const pendingSessions = httpsCallable(functions, "pendingSessions");
+    try {
+      const result = await pendingSessions({ projectId: projectId || null });
+      const pending = result.data.pending;
+      if (pending.length === 0) {
+        console.log("No sessions awaiting analysis.");
+      } else {
+        console.log(`${pending.length} session(s) awaiting analysis:\n`);
+        for (const s of pending) {
+          console.log(`  Session: ${s.sessionId}`);
+          console.log(`  Template: ${s.templateName}`);
+          console.log(`  Tester: ${s.tester}`);
+          console.log(`  Date: ${s.testDate}`);
+          console.log(`  Failures: ${s.failCount}/${s.totalTests}`);
+          console.log("");
+        }
+      }
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("backlog")
+  .description("List backlog items for configured project")
+  .option("--sprint <id>", "Filter by sprint ID")
+  .option("--status <statuses>", "Filter by status (comma-separated: new,in_progress,on_hold)")
+  .option("--assigned <email>", "Filter by assignee")
+  .option("-o, --output <path>", "Output file (default: stdout)")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    const creds = getCredentials();
+    if (!creds?.projectId) { console.error("No project configured. Run: qatools setup"); process.exit(1); }
+
+    const listBacklog = httpsCallable(functions, "listBacklog");
+    try {
+      const filters = { projectId: creds.projectId };
+      if (options.sprint) filters.sprintId = options.sprint;
+      if (options.status) filters.status = options.status.split(",");
+      if (options.assigned) filters.assignedTo = options.assigned;
+      const result = await listBacklog(filters);
+      const data = result.data;
+
+      if (options.output) {
+        fs.writeFileSync(path.resolve(options.output), JSON.stringify(data, null, 2));
+        console.error(`Written ${data.items.length} items to ${options.output}`);
+      } else {
+        console.log(JSON.stringify(data, null, 2));
+      }
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("sprint-items")
+  .description("List all items in a sprint")
+  .requiredOption("--sprint <id>", "Sprint ID")
+  .option("-o, --output <path>", "Output file")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    const creds = getCredentials();
+    if (!creds?.projectId) { console.error("No project configured. Run: qatools setup"); process.exit(1); }
+
+    const getSprintItems = httpsCallable(functions, "getSprintItems");
+    try {
+      const result = await getSprintItems({ projectId: creds.projectId, sprintId: options.sprint });
+      const data = result.data;
+      if (options.output) {
+        fs.writeFileSync(path.resolve(options.output), JSON.stringify(data, null, 2));
+        console.error(`Sprint: ${data.sprint?.name || "unknown"} — ${data.items.length} items`);
+      } else {
+        console.log(JSON.stringify(data, null, 2));
+      }
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("sprints")
+  .description("List sprints for configured project")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    const creds = getCredentials();
+    if (!creds?.projectId) { console.error("No project configured. Run: qatools setup"); process.exit(1); }
+
+    const listSprints = httpsCallable(functions, "listSprints");
+    try {
+      const result = await listSprints({ projectId: creds.projectId });
+      for (const s of result.data.sprints) {
+        console.log(`  ${s.id}  ${s.name}  [${s.status}]  Release: ${s.releaseDate || "N/A"}`);
+      }
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("backlog-create")
+  .description("Create a new backlog item")
+  .requiredOption("-d, --description <text>", "Description")
+  .option("-t, --type <type>", "Type: bug, task, improvement, feature, epic, story", "task")
+  .option("--priority <n>", "Priority: 1 (high), 2 (medium), 3 (low)", "2")
+  .option("--assigned <email>", "Assign to")
+  .option("--sprint <id>", "Sprint ID")
+  .option("--parent <label>", "Parent item label (e.g. STORY-5)")
+  .option("--requirement-key <key>", "Requirement key (e.g. auth.login)")
+  .option("--tags <tags>", "Tags (comma-separated)")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    const creds = getCredentials();
+    if (!creds?.projectId) { console.error("No project configured. Run: qatools setup"); process.exit(1); }
+
+    const createItem = httpsCallable(functions, "createBacklogItem");
+    try {
+      const result = await createItem({
+        projectId: creds.projectId,
+        type: options.type,
+        description: options.description,
+        priority: parseInt(options.priority, 10),
+        assignedTo: options.assigned || "",
+        sprintId: options.sprint || "",
+        parentId: options.parent || "",
+        requirementKey: options.requirementKey || "",
+        tags: options.tags ? options.tags.split(",").map(t => t.trim()) : [],
+      });
+      console.log(`Created: ${result.data.type.toUpperCase()}-${result.data.bugNumber} (${result.data.id})`);
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("templates")
+  .description("List templates and their review status")
+  .option("--status <status>", "Filter: draft, pending_review, approved, rejected")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    const creds = getCredentials();
+    if (!creds?.projectId) { console.error("No project configured. Run: qatools setup"); process.exit(1); }
+
+    const listTemplates = httpsCallable(functions, "listTemplates");
+    try {
+      const result = await listTemplates({ projectId: creds.projectId, status: options.status || null });
+      const templates = result.data.templates;
+      if (templates.length === 0) {
+        console.log("No templates found.");
+      } else {
+        for (const t of templates) {
+          const statusIcon = { draft: "📝", pending_review: "🔍", approved: "✅", rejected: "❌" }[t.status] || "?";
+          console.log(`  ${statusIcon} ${t.name} v${t.version || "-"} [${t.status}] (${t.sectionsCount} sections) ID: ${t.id}`);
+          if (t.reviewComment) console.log(`     💬 ${t.reviewComment}`);
+        }
+      }
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("requirement-keys")
+  .description("List all requirement keys in the project (from backlog + templates)")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    const creds = getCredentials();
+    if (!creds?.projectId) { console.error("No project configured. Run: qatools setup"); process.exit(1); }
+
+    const listKeys = httpsCallable(functions, "listRequirementKeys");
+    try {
+      const result = await listKeys({ projectId: creds.projectId });
+      const keys = result.data.keys;
+      if (keys.length === 0) {
+        console.log("No requirement keys found.");
+      } else {
+        console.log(`\n${keys.length} requirement keys:\n`);
+        for (const k of keys) {
+          const src = k.source === "backlog" ? `${k.type?.toUpperCase()}-${k.bugNumber} [${k.status}]` : `test ${k.testId}`;
+          console.log(`  ${k.key}`);
+          console.log(`    ${k.description}`);
+          console.log(`    Source: ${src}`);
+          console.log();
+        }
+      }
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("template-upload")
+  .description("Upload a test template JSON to the project")
+  .requiredOption("-f, --file <path>", "Path to template JSON file")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+    const creds = getCredentials();
+    if (!creds?.projectId) { console.error("No project configured. Run: qatools setup"); process.exit(1); }
+
+    const filePath = path.resolve(options.file);
+    if (!fs.existsSync(filePath)) { console.error(`File not found: ${filePath}`); process.exit(1); }
+
+    const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!data.name || !data.sections) { console.error("JSON must have 'name' and 'sections'"); process.exit(1); }
+
+    const uploadTemplate = httpsCallable(functions, "uploadTemplate");
+    try {
+      const result = await uploadTemplate({
+        projectId: creds.projectId,
+        name: data.name,
+        version: data.version || "",
+        sections: data.sections,
+      });
+      console.log(`Template uploaded: ${result.data.name} (${result.data.sectionsCount} sections)`);
+      console.log(`ID: ${result.data.id}`);
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("backlog-update")
+  .description("Update one or more backlog items (JSON file or inline)")
+  .option("-f, --file <path>", "JSON file with updates: { '<id>': { status, comment, ... } }")
+  .option("-i, --id <id>", "Single item ID to update")
+  .option("--status <status>", "New status")
+  .option("--comment <text>", "Add comment")
+  .option("--assigned <email>", "Assign to")
+  .option("--tester <email>", "Set tester")
+  .option("--author <name>", "Author name for comments (default: your email)", "Claude")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .action(async (options) => {
+    await authenticate(options);
+
+    let updates = {};
+    if (options.file) {
+      updates = JSON.parse(fs.readFileSync(path.resolve(options.file), "utf-8"));
+      // Add authorName to all items with comments
+      for (const u of Object.values(updates)) {
+        if (u.comment && !u.authorName) u.authorName = options.author;
+      }
+    } else if (options.id) {
+      const u = {};
+      if (options.status) u.status = options.status;
+      if (options.comment) { u.comment = options.comment; u.authorName = options.author; }
+      if (options.assigned) u.assignedTo = options.assigned;
+      if (options.tester) u.tester = options.tester;
+      updates[options.id] = u;
+    } else {
+      console.error("Provide --file or --id");
+      process.exit(1);
+    }
+
+    const updateItems = httpsCallable(functions, "updateBacklogItems");
+    try {
+      const result = await updateItems({ updates });
+      console.log(`Updated ${result.data.updatedCount} item(s)`);
+    } catch (e) {
+      console.error("Failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+
+program
+  .command("login")
+  .description("Save credentials to ~/.qatools (email/password or --google)")
+  .option("-e, --email <email>", "Login email")
+  .option("-p, --password <password>", "Login password")
+  .option("-g, --google", "Login with Google (opens browser)")
+  .action(async (options) => {
+    const configPath = path.join(process.env.HOME || process.env.USERPROFILE, ".qatools");
+
+    if (options.google) {
+      // Google login via browser
+      console.log("Opening browser for Google sign-in...\n");
+      // Find a free port
+      const port = await new Promise((resolve, reject) => {
+        const srv = http.createServer();
+        srv.listen(0, () => { const p = srv.address().port; srv.close(() => resolve(p)); });
+        srv.on("error", reject);
+      });
+
+      const tokenPromise = new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+          // CORS headers
+          res.setHeader("Access-Control-Allow-Origin", "*");
+          res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+          res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+          if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }
+
+          if (req.method === "POST" && req.url === "/callback") {
+            let body = "";
+            req.on("data", chunk => body += chunk);
+            req.on("end", () => {
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ ok: true }));
+              server.close();
+              try { resolve(JSON.parse(body)); } catch { reject(new Error("Invalid response")); }
+            });
+          } else {
+            res.writeHead(404); res.end();
+          }
+        });
+
+        server.listen(port, () => {
+          const url = `https://qa-tools.com/cli-auth?port=${port}`;
+          if (process.platform === "win32") {
+            require("child_process").exec(`rundll32 url.dll,FileProtocolHandler ${url}`);
+          } else if (process.platform === "darwin") {
+            require("child_process").exec(`open "${url}"`);
+          } else {
+            require("child_process").exec(`xdg-open "${url}"`);
+          }
+          console.log(`Waiting for sign-in at ${url}`);
+          console.log("(If browser didn't open, go to the URL manually)\n");
+        });
+
+        setTimeout(() => { server.close(); reject(new Error("Timeout — no sign-in received after 2 minutes")); }, 120000);
+      });
+
+      try {
+        const { refreshToken, email } = await tokenPromise;
+        console.log(`Received token for ${email}. Verifying...`);
+        // Load existing config to preserve projectId
+        let existing = {};
+        if (fs.existsSync(configPath)) {
+          try { existing = JSON.parse(fs.readFileSync(configPath, "utf-8")); } catch {}
+        }
+        const config = { ...existing, email, refreshToken };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(`Logged in as ${email}`);
+        console.log(`Credentials saved to ${configPath}`);
+      } catch (e) {
+        console.error("Login failed:", e.message);
+        process.exit(1);
+      }
+    } else {
+      // Email/password login
+      if (!options.email || !options.password) {
+        console.error("Use --google or provide --email and --password");
+        process.exit(1);
+      }
+      try {
+        await signInWithEmailAndPassword(auth, options.email, options.password);
+      } catch (e) {
+        console.error("Login failed:", e.message);
+        process.exit(1);
+      }
+      let existing = {};
+      if (fs.existsSync(configPath)) {
+        try { existing = JSON.parse(fs.readFileSync(configPath, "utf-8")); } catch {}
+      }
+      const config = { ...existing, email: options.email, password: options.password };
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(`Credentials saved to ${configPath}`);
+    }
+    process.exit(0);
+  });
+
+program.parse();