@codeguide/core 0.0.28 → 0.0.29

package/docs/testsprite_tests/TC009_SEO_and_Content_Discoverability_Verification.py

@@ -0,0 +1,73 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Inspect additional documentation pages to verify consistent presence of meta tags, descriptions, structured data, and semantic URLs.
+        frame = context.pages[-1]
+        # Click on 'Getting Started' link to inspect its SEO elements
+        elem = frame.locator('xpath=html/body/div/div/div/div/div[3]/div/div/h2[4]/a').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        try:
+            await expect(frame.locator('text=SEO Optimization Complete').first).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError('Test case failed: The test plan execution has failed because the page does not include proper meta tags, titles, descriptions, and structured content to meet SEO standards.')
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC010_Accessibility_Compliance_WCAG_AA.py

@@ -0,0 +1,73 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Navigate through the site using keyboard only (Tab, Shift+Tab, Enter, arrow keys) to verify focus order and reachability of interactive elements.
+        frame = context.pages[-1]
+        # Focus on 'Skip to content' link to start keyboard navigation testing
+        elem = frame.locator('xpath=html/body/div/div/header/div/div/div/div/div/a').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        try:
+            await expect(frame.locator('text=Accessibility Compliance Verified').first).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError('Test case failed: The documentation site did not meet accessibility standards for keyboard navigation, color contrast, and screen reader compatibility as per WCAG AA requirements.')
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC011_Local_Development_Workflow_Build_and_Hot_Reload.py

@@ -0,0 +1,74 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        await expect(frame.locator('text=Complete TypeScript SDK for integrating CodeGuide functionality into your applications.').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=Database API keys, legacy keys, and JWT tokens with automatic fallback').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=Create, update, and manage projects programmatically with full CRUD operations').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=Create and manage AI-powered coding tasks with support for multiple execution modes').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=Query and manage LLM models and providers for your codespace tasks').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=Securely manage provider API keys and GitHub tokens with encryption').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=Full type safety and IntelliSense support for all API methods').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=npm install @codeguide/core').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=const project = await codeguide.projects.createProject({ title: 'My New Project', description: 'Project description here' });').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=const task = await codeguide.codespace.createCodespaceTaskV2({ project_id: project.id, task_description: 'Implement user authentication', execution_mode: 'implementation' });').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=await codeguide.securityKeys.createProviderAPIKey({ provider_key: 'openai', api_key: 'sk-your-openai-key' });').first).to_be_visible(timeout=30000)
+        await expect(frame.locator('text=await codeguide.securityKeys.createGitHubToken({ github_token: 'ghp_your_github_token' });').first).to_be_visible(timeout=30000)
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC012_Performance_Metrics_Compliance.py

@@ -0,0 +1,73 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Select the 'Getting Started' documentation page to measure FCP and CLS.
+        frame = context.pages[-1]
+        # Click on 'Getting Started' documentation page link
+        elem = frame.locator('xpath=html/body/div/div/header/div/div/div/div[2]/div/nav/a[2]').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        try:
+            await expect(frame.locator('text=Performance Targets Met Successfully').first).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError("Test case failed: The documentation site did not meet the performance targets. FCP was not under 1.5 seconds, CLS was not below 0.1, or the page did not load fully within 2 seconds on standard broadband.")
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/standard_prd.json

@@ -0,0 +1,122 @@
+{
+  "meta": {
+    "project": "VitePress Documentation Site for @codeguide/core",
+    "date": "2025-11-04",
+    "prepared_by": "CodeGuide Team"
+  },
+  "product_overview": "A modern, fast, and developer-friendly documentation site for the @codeguide/core TypeScript SDK, implemented with VitePress. It offers a searchable, navigable, mobile-responsive, dark-mode supported platform integrated seamlessly with GitHub to enhance developer experience and SDK adoption.",
+  "core_goals": [
+    "Migrate traditional markdown documentation to an interactive, searchable site.",
+    "Provide an intuitive and fast-loading documentation experience with excellent navigation.",
+    "Enable easy content updates and community contributions using markdown authoring.",
+    "Improve SEO and content discoverability for the SDK documentation.",
+    "Ensure brand consistency with cohesive styling and theming matching CodeGuide standards."
+  ],
+  "key_features": [
+    "Homepage featuring a hero section with quick start guidance and feature highlights.",
+    "Hierarchical and collapsible sidebar navigation organized by documentation topics.",
+    "Full-text local search across all markdown content with keyboard shortcuts and results highlighting.",
+    "Dark mode support with automatic system theme detection and manual toggle persisting user preferences.",
+    "Mobile-responsive design optimized for various device sizes with touch-friendly navigation.",
+    "GitHub integration with 'Edit this page' links and repository social icons.",
+    "Syntax highlighting for TypeScript and JavaScript code samples with copy functionality.",
+    "Auto-generated table of contents and structured content layout.",
+    "Custom branding and styling including brand colors and enhanced UI components.",
+    "Development workflows for easy local content updates, preview, and build processes."
+  ],
+  "user_flow_summary": [
+    "User lands on the homepage to view hero message, features, and quick start guide.",
+    "User navigates through sidebar or top navigation to explore documentation sections.",
+    "User performs a search using Ctrl/Cmd+K to find specific information with highlighted results.",
+    "User toggles dark mode manually or uses system preference to switch themes.",
+    "User clicks 'Edit this page on GitHub' to propose changes or view source file.",
+    "User accesses documentation on mobile device with responsive menu and touch support.",
+    "Developers update documentation by editing markdown files locally and preview changes with hot reload.",
+    "Content is built and deployed through CI/CD pipelines to static hosting platforms."
+  ],
+  "validation_criteria": [
+    "Documentation site loads under 2 seconds on standard broadband connections.",
+    "Full-text search returns accurate results with fast response and supports keyboard navigation.",
+    "Dark mode toggle works correctly and persists user choice across sessions.",
+    "Mobile responsiveness verified on common device screen sizes with smooth navigation.",
+    "GitHub edit links direct correctly to corresponding markdown files in repository.",
+    "Code highlighting accurately presents TypeScript/JavaScript samples with line numbers and copy feature.",
+    "All navigation links correctly route within the site with active page highlighting.",
+    "Performance metrics meet or exceed targets (e.g. FCP < 1.5s, CLS < 0.1).",
+    "Accessibility standards (WCAG AA) met including keyboard navigation and color contrast.",
+    "Successful local development workflow with no build errors and hot module replacement functioning."
+  ],
+  "code_summary": {
+    "tech_stack": [
+      "VitePress",
+      "Vue.js",
+      "TypeScript",
+      "Markdown"
+    ],
+    "features": [
+      {
+        "name": "generateQuestionnaire",
+        "description": "Generates a questionnaire for a task description to gather additional context. Supports task description, project context, repository info, and file attachments.",
+        "files": [
+          "codespace-service.md"
+        ]
+      },
+      {
+        "name": "createCodespaceTask",
+        "description": "Creates a codespace task using the legacy endpoint for backward compatibility. Supports task title, description, and optional conversation ID.",
+        "files": [
+          "codespace-service.md"
+        ]
+      },
+      {
+        "name": "getCodespaceModels",
+        "description": "Retrieves all available codespace models with optional filtering by provider ID or execution mode. Returns models with provider information.",
+        "files": [
+          "codespace-service.md"
+        ]
+      },
+      {
+        "name": "getCodespaceModel",
+        "description": "Retrieves a specific codespace model by ID with provider information including name, execution mode, and base URLs.",
+        "files": [
+          "codespace-service.md"
+        ]
+      },
+      {
+        "name": "getLLMModelProviders",
+        "description": "Retrieves all available LLM model providers with their IDs, names, keys, and logo sources.",
+        "files": [
+          "codespace-service.md"
+        ]
+      },
+      {
+        "name": "getLLMModelProvider",
+        "description": "Retrieves a specific LLM model provider by ID with complete provider information.",
+        "files": [
+          "codespace-service.md"
+        ]
+      },
+      {
+        "name": "getModelsByProvider",
+        "description": "Retrieves all models for a specific provider by provider ID, returning an array of codespace models.",
+        "files": [
+          "codespace-service.md"
+        ]
+      },
+      {
+        "name": "TypeExports",
+        "description": "Exports TypeScript type definitions for codespace service including request/response types, task types, model types, and provider types.",
+        "files": [
+          "codespace-service.md"
+        ]
+      },
+      {
+        "name": "RelatedDocumentation",
+        "description": "Provides cross-references to related documentation including Codespace Models, Projects Service, and CodeGuide Client documentation.",
+        "files": [
+          "codespace-service.md"
+        ]
+      }
+    ]
+  }
+}