@cliangdev/flux-plugin 0.0.0-dev.cbdf207 → 0.0.0-dev.df3e9bb

package/src/server/adapters/__tests__/linear-criteria-parser.test.ts

@@ -0,0 +1,287 @@
+import { describe, expect, test } from "bun:test";
+import {
+  addCriterionToDescription,
+  generateCriteriaId,
+  parseCriteriaFromDescription,
+  updateCriterionInDescription,
+} from "../linear/helpers/criteria-parser.js";
+
+describe("criteria-parser", () => {
+  describe("generateCriteriaId", () => {
+    test("generates stable hash-based IDs", () => {
+      const id1 = generateCriteriaId("User can sign in");
+      const id2 = generateCriteriaId("User can sign in");
+      expect(id1).toBe(id2);
+    });
+
+    test("generates different IDs for different text", () => {
+      const id1 = generateCriteriaId("User can sign in");
+      const id2 = generateCriteriaId("User can sign out");
+      expect(id1).not.toBe(id2);
+    });
+
+    test("ID format is ac_ prefix with 8 hex chars", () => {
+      const id = generateCriteriaId("Test criterion");
+      expect(id).toMatch(/^ac_[a-f0-9]{8}$/);
+    });
+
+    test("trims whitespace for consistent IDs", () => {
+      const id1 = generateCriteriaId("  Test  ");
+      const id2 = generateCriteriaId("Test");
+      expect(id1).toBe(id2);
+    });
+  });
+
+  describe("parseCriteriaFromDescription", () => {
+    test("returns empty array for undefined description", () => {
+      const result = parseCriteriaFromDescription(undefined);
+      expect(result).toEqual([]);
+    });
+
+    test("returns empty array for empty description", () => {
+      const result = parseCriteriaFromDescription("");
+      expect(result).toEqual([]);
+    });
+
+    test("parses unchecked checkboxes with dash", () => {
+      const description = "- [ ] First item\n- [ ] Second item";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(2);
+      expect(result[0].text).toBe("First item");
+      expect(result[0].isMet).toBe(false);
+      expect(result[1].text).toBe("Second item");
+      expect(result[1].isMet).toBe(false);
+    });
+
+    test("parses checked checkboxes with lowercase x", () => {
+      const description = "- [x] Completed item";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(1);
+      expect(result[0].text).toBe("Completed item");
+      expect(result[0].isMet).toBe(true);
+    });
+
+    test("parses checked checkboxes with uppercase X", () => {
+      const description = "- [X] Completed item";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(1);
+      expect(result[0].isMet).toBe(true);
+    });
+
+    test("parses checkboxes with asterisk", () => {
+      const description = "* [ ] Item with asterisk";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(1);
+      expect(result[0].text).toBe("Item with asterisk");
+    });
+
+    test("handles indented checkboxes", () => {
+      const description = "  - [ ] Indented item";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(1);
+      expect(result[0].text).toBe("Indented item");
+    });
+
+    test("parses only AC section when header is present", () => {
+      const description = `# Overview
+Some overview text
+
+- [ ] Not a criterion
+
+## Acceptance Criteria
+
+- [ ] Real criterion 1
+- [x] Real criterion 2
+
+## Notes
+- [ ] Not a criterion either`;
+
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(2);
+      expect(result[0].text).toBe("Real criterion 1");
+      expect(result[1].text).toBe("Real criterion 2");
+    });
+
+    test("parses AC section with bold header", () => {
+      const description = `**Acceptance Criteria**
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+**Notes**
+- [ ] Not a criterion`;
+
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(2);
+    });
+
+    test("includes line index for updates", () => {
+      const description = "Header\n\n- [ ] Item 1\n- [ ] Item 2";
+      const result = parseCriteriaFromDescription(description);
+      expect(result[0].lineIndex).toBe(2);
+      expect(result[1].lineIndex).toBe(3);
+    });
+
+    test("generates correct IDs for criteria", () => {
+      const description = "- [ ] Test criterion";
+      const result = parseCriteriaFromDescription(description);
+      const expectedId = generateCriteriaId("Test criterion");
+      expect(result[0].id).toBe(expectedId);
+    });
+  });
+
+  describe("updateCriterionInDescription", () => {
+    test("marks criterion as met", () => {
+      const description = "- [ ] First item\n- [ ] Second item";
+      const criteriaId = generateCriteriaId("First item");
+      const result = updateCriterionInDescription(
+        description,
+        criteriaId,
+        true,
+      );
+      expect(result).toBe("- [x] First item\n- [ ] Second item");
+    });
+
+    test("marks criterion as unmet", () => {
+      const description = "- [x] First item\n- [ ] Second item";
+      const criteriaId = generateCriteriaId("First item");
+      const result = updateCriterionInDescription(
+        description,
+        criteriaId,
+        false,
+      );
+      expect(result).toBe("- [ ] First item\n- [ ] Second item");
+    });
+
+    test("preserves indentation", () => {
+      const description = "  - [ ] Indented item";
+      const criteriaId = generateCriteriaId("Indented item");
+      const result = updateCriterionInDescription(
+        description,
+        criteriaId,
+        true,
+      );
+      expect(result).toBe("  - [x] Indented item");
+    });
+
+    test("throws for non-existent criterion", () => {
+      const description = "- [ ] Item";
+      expect(() =>
+        updateCriterionInDescription(description, "ac_nonexist", true),
+      ).toThrow("Criterion not found");
+    });
+
+    test("updates correct criterion when multiple exist", () => {
+      const description = "- [ ] First\n- [ ] Second\n- [ ] Third";
+      const criteriaId = generateCriteriaId("Second");
+      const result = updateCriterionInDescription(
+        description,
+        criteriaId,
+        true,
+      );
+      expect(result).toBe("- [ ] First\n- [x] Second\n- [ ] Third");
+    });
+  });
+
+  describe("addCriterionToDescription", () => {
+    test("creates AC section for undefined description", () => {
+      const result = addCriterionToDescription(undefined, "New criterion");
+      expect(result).toBe("## Acceptance Criteria\n\n- [ ] New criterion");
+    });
+
+    test("creates AC section for empty description", () => {
+      const result = addCriterionToDescription("", "New criterion");
+      expect(result).toContain("## Acceptance Criteria");
+      expect(result).toContain("- [ ] New criterion");
+    });
+
+    test("adds to existing AC section", () => {
+      const description = `## Acceptance Criteria
+
+- [ ] Existing criterion`;
+
+      const result = addCriterionToDescription(description, "New criterion");
+      expect(result).toContain("- [ ] Existing criterion");
+      expect(result).toContain("- [ ] New criterion");
+    });
+
+    test("inserts after last checkbox in AC section", () => {
+      const description = `## Acceptance Criteria
+
+- [ ] First
+- [ ] Second
+
+## Notes
+Some notes`;
+
+      const result = addCriterionToDescription(description, "Third");
+      const lines = result.split("\n");
+      const thirdIndex = lines.findIndex((l) => l.includes("Third"));
+      const notesIndex = lines.findIndex((l) => l.includes("## Notes"));
+      expect(thirdIndex).toBeLessThan(notesIndex);
+    });
+
+    test("preserves description content before AC section", () => {
+      const description = `# Overview
+
+This is an overview.
+
+## Acceptance Criteria
+
+- [ ] Existing`;
+
+      const result = addCriterionToDescription(description, "New");
+      expect(result).toContain("# Overview");
+      expect(result).toContain("This is an overview.");
+    });
+
+    test("creates AC section at end if none exists", () => {
+      const description = `# Overview
+
+Some content here.`;
+
+      const result = addCriterionToDescription(description, "New criterion");
+      expect(result).toContain("# Overview");
+      expect(result).toContain("Some content here.");
+      expect(result).toContain("## Acceptance Criteria");
+      expect(result).toContain("- [ ] New criterion");
+    });
+  });
+
+  describe("integration: parse, update, parse cycle", () => {
+    test("round-trip preserves structure", () => {
+      const original = `## Acceptance Criteria
+
+- [ ] User can login
+- [ ] User can logout
+- [ ] Session persists`;
+
+      const parsed = parseCriteriaFromDescription(original);
+      expect(parsed).toHaveLength(3);
+
+      const updated = updateCriterionInDescription(
+        original,
+        parsed[1].id,
+        true,
+      );
+      const reParsed = parseCriteriaFromDescription(updated);
+
+      expect(reParsed).toHaveLength(3);
+      expect(reParsed[0].isMet).toBe(false);
+      expect(reParsed[1].isMet).toBe(true);
+      expect(reParsed[2].isMet).toBe(false);
+    });
+
+    test("add and parse cycle", () => {
+      let description = "## Overview\n\nSome text";
+
+      description = addCriterionToDescription(description, "First");
+      description = addCriterionToDescription(description, "Second");
+
+      const parsed = parseCriteriaFromDescription(description);
+      expect(parsed).toHaveLength(2);
+      expect(parsed.map((c) => c.text)).toContain("First");
+      expect(parsed.map((c) => c.text)).toContain("Second");
+    });
+  });
+});

package/src/server/adapters/__tests__/linear-description-test.ts

@@ -0,0 +1,238 @@
+/**
+ * Linear Description Validation Test
+ *
+ * This test verifies that Linear issue descriptions can handle PRD-equivalent content
+ * including rich markdown, images, and diagrams. Run this test manually against a
+ * real Linear instance before proceeding with the refactor.
+ *
+ * Usage:
+ *   FLUX_LINEAR_API_KEY=lin_api_xxx FLUX_LINEAR_TEAM_ID=xxx bun run test:linear-description
+ *
+ * Note: This is an integration test that requires real Linear credentials.
+ * It creates and then archives a test issue.
+ */
+
+import { LinearClient } from "@linear/sdk";
+
+/**
+ * Sample PRD content with rich markdown formatting.
+ * This simulates what would be stored in a PRD issue description.
+ */
+const SAMPLE_PRD_CONTENT = `# Feature: User Authentication
+
+## Overview
+Implement OAuth2 login with Google and GitHub providers. This feature enables users to sign in without creating a new password and provides a seamless authentication experience.
+
+## User Stories
+- As a user, I want to sign in with Google so I don't need another password
+- As a user, I want to link multiple auth providers to one account
+- As a user, I want to see which providers are linked to my account
+- As a security-conscious user, I want to unlink providers I no longer use
+
+## Requirements
+
+### Functional Requirements
+1. **Google OAuth Integration**
+   - Support Google OAuth 2.0 flow
+   - Request minimal scopes (email, profile)
+   - Handle token refresh automatically
+
+2. **GitHub OAuth Integration**
+   - Support GitHub OAuth flow
+   - Request read:user scope
+   - Handle organization restrictions
+
+3. **Account Linking**
+   - Allow linking multiple providers to one account
+   - Prevent duplicate email conflicts
+   - Support unlinking providers (min 1 must remain)
+
+### Non-Functional Requirements
+- Authentication response time < 2 seconds
+- Support 1000 concurrent auth requests
+- 99.9% uptime for auth service
+
+## Wireframe
+![Login Screen](https://via.placeholder.com/400x300?text=Login+Wireframe)
+
+## Architecture
+
+\`\`\`mermaid
+graph LR
+    A[Client] --> B[Auth Service]
+    B --> C[Google OAuth]
+    B --> D[GitHub OAuth]
+    B --> E[Session Store]
+    E --> F[(Redis)]
+    B --> G[(PostgreSQL)]
+\`\`\`
+
+## API Design
+
+### POST /auth/google
+\`\`\`json
+{
+  "code": "google_auth_code",
+  "redirect_uri": "https://app.example.com/callback"
+}
+\`\`\`
+
+### POST /auth/github
+\`\`\`json
+{
+  "code": "github_auth_code",
+  "redirect_uri": "https://app.example.com/callback"
+}
+\`\`\`
+
+## Acceptance Criteria
+- [ ] Google OAuth integration working
+- [ ] GitHub OAuth integration working
+- [ ] Session management implemented
+- [ ] Account linking/unlinking functional
+- [ ] Error handling for OAuth failures
+- [ ] Rate limiting on auth endpoints
+- [ ] Audit logging for auth events
+
+## Technical Notes
+- Use \`passport.js\` for OAuth abstraction
+- Store refresh tokens encrypted with AES-256
+- Implement PKCE for mobile clients
+
+## Dependencies
+- passport: ^0.7.0
+- passport-google-oauth20: ^2.0.0
+- passport-github2: ^0.1.12
+- ioredis: ^5.3.0
+`;
+
+/**
+ * Run the validation test.
+ * This creates an issue, verifies content, and archives it.
+ */
+async function runValidationTest() {
+  const apiKey = process.env.FLUX_LINEAR_API_KEY;
+  const teamId = process.env.FLUX_LINEAR_TEAM_ID;
+
+  if (!apiKey || !teamId) {
+    console.error("Missing required environment variables:");
+    console.error("  FLUX_LINEAR_API_KEY - Your Linear API key (lin_api_...)");
+    console.error("  FLUX_LINEAR_TEAM_ID - Your Linear team ID");
+    console.error("");
+    console.error("Usage:");
+    console.error(
+      "  FLUX_LINEAR_API_KEY=lin_api_xxx FLUX_LINEAR_TEAM_ID=xxx bun run test:linear-description",
+    );
+    process.exit(1);
+  }
+
+  const client = new LinearClient({ apiKey });
+
+  console.log("=== Linear Description Validation Test ===\n");
+
+  // 1. Create test issue with rich markdown content
+  console.log("1. Creating test issue with PRD-equivalent content...");
+  console.log(`   Content length: ${SAMPLE_PRD_CONTENT.length} characters`);
+
+  const createResult = await client.createIssue({
+    title: "[TEST] PRD Description Validation - Can Delete",
+    description: SAMPLE_PRD_CONTENT,
+    teamId,
+  });
+
+  if (!createResult.success) {
+    console.error("   ❌ Failed to create issue");
+    process.exit(1);
+  }
+
+  const issue = await createResult.issue;
+  if (!issue) {
+    console.error("   ❌ Issue not returned after creation");
+    process.exit(1);
+  }
+
+  console.log(`   ✅ Issue created: ${issue.identifier}`);
+  console.log(`   URL: ${issue.url}`);
+
+  // 2. Fetch the issue back and verify content
+  console.log("\n2. Fetching issue to verify content preservation...");
+
+  const fetchedIssue = await client.issue(issue.id);
+  if (!fetchedIssue) {
+    console.error("   ❌ Failed to fetch issue");
+    process.exit(1);
+  }
+
+  const description = fetchedIssue.description || "";
+  console.log(
+    `   Retrieved description length: ${description.length} characters`,
+  );
+
+  // Verify key sections are present
+  const requiredSections = [
+    "# Feature: User Authentication",
+    "## Overview",
+    "## User Stories",
+    "## Requirements",
+    "## Wireframe",
+    "## Architecture",
+    "```mermaid",
+    "## API Design",
+    "## Acceptance Criteria",
+    "- [ ] Google OAuth integration working",
+    "## Technical Notes",
+    "## Dependencies",
+  ];
+
+  let allSectionsFound = true;
+  for (const section of requiredSections) {
+    if (description.includes(section)) {
+      console.log(`   ✅ Found: "${section.substring(0, 40)}..."`);
+    } else {
+      console.log(`   ❌ Missing: "${section.substring(0, 40)}..."`);
+      allSectionsFound = false;
+    }
+  }
+
+  // 3. Check image URL preservation
+  console.log("\n3. Checking image URL preservation...");
+  const imageUrl = "https://via.placeholder.com/400x300?text=Login+Wireframe";
+  if (description.includes(imageUrl)) {
+    console.log(`   ✅ Image URL preserved: ${imageUrl}`);
+  } else {
+    console.log(`   ⚠️ Image URL may have been processed/modified by Linear`);
+  }
+
+  // 4. Archive the test issue (cleanup)
+  console.log("\n4. Archiving test issue (cleanup)...");
+  const archiveResult = await fetchedIssue.archive();
+  if (archiveResult.success) {
+    console.log("   ✅ Test issue archived successfully");
+  } else {
+    console.log("   ⚠️ Failed to archive test issue - please delete manually");
+    console.log(`   Issue identifier: ${issue.identifier}`);
+  }
+
+  // Summary
+  console.log("\n=== Validation Summary ===");
+  if (allSectionsFound) {
+    console.log("✅ SUCCESS: Linear issue descriptions can handle PRD content");
+    console.log("   - All markdown sections preserved");
+    console.log("   - Content length is acceptable");
+    console.log("   - Ready to proceed with refactor");
+  } else {
+    console.log("⚠️ PARTIAL: Some content may be modified by Linear");
+    console.log("   - Check the issue in Linear UI to verify rendering");
+    console.log("   - Some markdown features may not be fully supported");
+  }
+
+  console.log(
+    `\nNote: Check the issue in Linear UI to verify images render correctly: ${issue.url}`,
+  );
+}
+
+// Run if executed directly
+runValidationTest().catch((error) => {
+  console.error("Test failed with error:", error);
+  process.exit(1);
+});