@popoverai/dotrequirements 0.24.0 → 0.24.2

package/dist/mcp/testCodeExtractor.js

@@ -1,150 +0,0 @@
-/**
- * Extract test code context using @babel/parser AST traversal.
- *
- * Finds requirement() call references and extracts the enclosing
- * meaningful code block (function, describe, test, etc.)
- */
-import * as fs from "node:fs";
-import { parse } from "@babel/parser";
-import traverse from "@babel/traverse";
-import * as t from "@babel/types";
-/**
- * Find all test code blocks that reference a specific requirement
- */
-export function findTestCodeForRequirement(filePath, requirementId) {
-    try {
-        const code = fs.readFileSync(filePath, "utf-8");
-        const results = [];
-        // Parse with TypeScript and JSX support
-        const ast = parse(code, {
-            sourceType: "module",
-            plugins: ["typescript", "jsx"],
-            errorRecovery: true,
-        });
-        // Handle both ES module and CommonJS exports
-        const traverseFunc = 
-        // biome-ignore lint/suspicious/noExplicitAny: @babel/traverse CJS default-export interop (callable function vs namespace import)
-        typeof traverse === "function" ? traverse : traverse.default;
-        traverseFunc(ast, {
-            CallExpression(path) {
-                // Check if this is a requirement('ID', ...) call
-                const callee = path.node.callee;
-                if (t.isIdentifier(callee) && callee.name === "requirement") {
-                    const args = path.node.arguments;
-                    // Extract all string literal arguments (supports multi-requirement calls)
-                    const refIds = [];
-                    for (const arg of args) {
-                        if (t.isStringLiteral(arg)) {
-                            refIds.push(arg.value);
-                        }
-                    }
-                    // Check if any argument matches the requirement we're looking for
-                    // Match exact ID or if it's a child (e.g., searching for REQ-123 matches REQ-123.0)
-                    for (const refId of refIds) {
-                        const isMatch = refId === requirementId || refId.startsWith(`${requirementId}.`);
-                        if (isMatch) {
-                            // Find the meaningful enclosing block
-                            const contextNode = findMeaningfulParent(path);
-                            if (contextNode?.node.loc) {
-                                const { start, end } = contextNode.node.loc;
-                                const nodeStart = contextNode.node.start ?? 0;
-                                const nodeEnd = contextNode.node.end ?? code.length;
-                                results.push({
-                                    file: filePath,
-                                    startLine: start.line,
-                                    endLine: end.line,
-                                    code: code.slice(nodeStart, nodeEnd),
-                                    requirementId: refId,
-                                });
-                            }
-                            // Only add one result per call expression, even if multiple refs match
-                            break;
-                        }
-                    }
-                }
-            },
-        });
-        return results;
-    }
-    catch (error) {
-        console.error(`Error parsing ${filePath}:`, error);
-        return [];
-    }
-}
-/**
- * Walk up the AST to find the nearest "meaningful" parent node.
- * This could be a function, describe/test/it call, method, etc.
- */
-function findMeaningfulParent(path) {
-    let current = path;
-    while (current) {
-        const node = current.node;
-        // Check for various meaningful boundaries
-        if (t.isFunctionDeclaration(node) ||
-            t.isFunctionExpression(node) ||
-            t.isArrowFunctionExpression(node) ||
-            t.isClassMethod(node) ||
-            t.isObjectMethod(node)) {
-            return current;
-        }
-        // Check for call expressions (describe, test, it, etc.)
-        if (t.isCallExpression(node)) {
-            const callee = node.callee;
-            // Common test framework function names
-            const testFunctionNames = [
-                "describe",
-                "it",
-                "test",
-                "suite",
-                "context",
-                "beforeEach",
-                "afterEach",
-                "beforeAll",
-                "afterAll",
-            ];
-            if (t.isIdentifier(callee) && testFunctionNames.includes(callee.name)) {
-                return current;
-            }
-        }
-        // Check for variable declarations that might contain test functions
-        if (t.isVariableDeclarator(node)) {
-            return current;
-        }
-        // Check for export declarations (for Storybook stories, etc.)
-        if (t.isExportNamedDeclaration(node) ||
-            t.isExportDefaultDeclaration(node)) {
-            return current;
-        }
-        current = current.parentPath;
-    }
-    return null;
-}
-/**
- * Find all files that reference a requirement
- */
-export function findFilesWithRequirement(files, requirementId) {
-    const matchingFiles = [];
-    for (const file of files) {
-        try {
-            const code = fs.readFileSync(file, "utf-8");
-            // Check for exact match or child references (e.g., AUTH-VALID-LOGIN or AUTH-VALID-LOGIN.0)
-            // Simple string search first for performance
-            // Patterns match both single and multi-arg calls:
-            //   requirement('REQ-123')
-            //   requirement('REQ-123', 'REQ-456')
-            //   requirement('REQ-456', 'REQ-123')  <-- ID anywhere in args
-            const hasMatch = code.includes(`'${requirementId}'`) ||
-                code.includes(`"${requirementId}"`) ||
-                code.includes(`\`${requirementId}\``) ||
-                code.includes(`'${requirementId}.`) ||
-                code.includes(`"${requirementId}.`) ||
-                code.includes(`\`${requirementId}.`);
-            if (hasMatch) {
-                matchingFiles.push(file);
-            }
-        }
-        catch (error) { }
-    }
-    return matchingFiles;
-}
-//# sourceMappingURL=testCodeExtractor.js.map

package/dist/mcp/types.d.ts

@@ -1,27 +0,0 @@
-/**
- * Re-export shared types from CLI schema module
- */
-export type { Metadata, RequirementNode, RequirementsFile, } from "../schema/index.js";
-/**
- * Flattened requirement for search results
- */
-export interface FlattenedRequirement {
-    id: string;
-    rootId: string;
-    label: string;
-    content: string;
-    path: string[];
-    sourceFile: string;
-    documentTitle: string;
-}
-/**
- * Test reference found in codebase
- */
-export interface TestReference {
-    file: string;
-    line: number;
-    column: number;
-    requirementId: string;
-    context: string;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/mcp/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/utils/local-project.d.ts

@@ -1,31 +0,0 @@
-/**
- * Utilities for detecting and working with local-only projects.
- *
- * Local-only projects use placeholder credentials and have no cloud features.
- */
-/**
- * Check if a project is local-only (no cloud features).
- *
- * Local-only projects have placeholder credentials:
- * - DOTREQUIREMENTS_PROJECT_ID=local
- * - DOTREQUIREMENTS_PROJECT_SECRET=local
- *
- * These projects can use local features (test harness, MCP local operations)
- * but cannot use cloud features (coverage reporting, push/pull, AI features).
- *
- * @param projectId - The project ID to check
- * @returns true if the project is local-only, false otherwise
- */
-export declare function isLocalOnlyProject(projectId: string | undefined): boolean;
-/**
- * Placeholder credentials for local-only projects.
- */
-export declare const LOCAL_PROJECT_CREDENTIALS: {
-    readonly projectId: "local";
-    readonly secret: "local";
-};
-/**
- * Error message for when cloud features are attempted on local-only projects.
- */
-export declare const CLOUD_FEATURES_REQUIRE_AUTH_MESSAGE = "Cloud features require authentication. Run `dotrequirements login` to enable cloud features.";
-//# sourceMappingURL=local-project.d.ts.map

package/dist/utils/local-project.js

@@ -1,33 +0,0 @@
-/**
- * Utilities for detecting and working with local-only projects.
- *
- * Local-only projects use placeholder credentials and have no cloud features.
- */
-/**
- * Check if a project is local-only (no cloud features).
- *
- * Local-only projects have placeholder credentials:
- * - DOTREQUIREMENTS_PROJECT_ID=local
- * - DOTREQUIREMENTS_PROJECT_SECRET=local
- *
- * These projects can use local features (test harness, MCP local operations)
- * but cannot use cloud features (coverage reporting, push/pull, AI features).
- *
- * @param projectId - The project ID to check
- * @returns true if the project is local-only, false otherwise
- */
-export function isLocalOnlyProject(projectId) {
-    return projectId === 'local';
-}
-/**
- * Placeholder credentials for local-only projects.
- */
-export const LOCAL_PROJECT_CREDENTIALS = {
-    projectId: 'local',
-    secret: 'local',
-};
-/**
- * Error message for when cloud features are attempted on local-only projects.
- */
-export const CLOUD_FEATURES_REQUIRE_AUTH_MESSAGE = 'Cloud features require authentication. Run `dotrequirements login` to enable cloud features.';
-//# sourceMappingURL=local-project.js.map

package/dist/utils/token-refresh.d.ts

@@ -1,24 +0,0 @@
-/**
- * Token refresh utilities for maintaining long-lived CLI sessions.
- *
- * WorkOS access tokens expire after 5 minutes, but refresh tokens can be used
- * to obtain new access/refresh token pairs. Refresh tokens are single-use and
- * get rotated on each refresh.
- */
-/**
- * Get a valid access token, refreshing if needed.
- *
- * This function should be called before making any authenticated Convex requests.
- * It checks if the current access token is expired and refreshes it if necessary.
- *
- * Returns null if no tokens are stored (user needs to login).
- */
-export declare function getValidAccessToken(): Promise<string | null>;
-/**
- * Ensure user is authenticated with a valid access token.
- *
- * Throws an error if not logged in or if token refresh fails.
- * Use this at the start of commands that require authentication.
- */
-export declare function requireAuth(): Promise<string>;
-//# sourceMappingURL=token-refresh.d.ts.map

package/dist/utils/token-refresh.js

@@ -1,69 +0,0 @@
-/**
- * Token refresh utilities for maintaining long-lived CLI sessions.
- *
- * WorkOS access tokens expire after 5 minutes, but refresh tokens can be used
- * to obtain new access/refresh token pairs. Refresh tokens are single-use and
- * get rotated on each refresh.
- */
-import { ConvexHttpClient } from 'convex/browser';
-import { getTokens, storeTokens, areTokensExpired } from './token-storage.js';
-import { getConvexUrl } from '../config.js';
-import { api } from '../convex.js';
-/**
- * Get a valid access token, refreshing if needed.
- *
- * This function should be called before making any authenticated Convex requests.
- * It checks if the current access token is expired and refreshes it if necessary.
- *
- * Returns null if no tokens are stored (user needs to login).
- */
-export async function getValidAccessToken() {
-    const tokens = await getTokens();
-    if (!tokens) {
-        return null; // Not logged in
-    }
-    // If tokens are still valid, return current access token
-    if (!areTokensExpired(tokens)) {
-        return tokens.accessToken;
-    }
-    // Tokens expired, refresh them
-    try {
-        console.log('Access token expired, refreshing...');
-        // Refresh tokens via Convex action (server-side WorkOS call)
-        const client = new ConvexHttpClient(getConvexUrl());
-        const result = await client.action(api.lib.authActions.refreshAccessToken, {
-            refreshToken: tokens.refreshToken,
-        });
-        if (!result.success) {
-            throw new Error(`Token refresh failed: ${result.error}`);
-        }
-        const { accessToken, refreshToken, expiresAt } = result;
-        // Store new tokens (IMPORTANT: refresh token is single-use, must update)
-        await storeTokens({
-            accessToken,
-            refreshToken, // New refresh token from response
-            expiresAt,
-        });
-        console.log('✓ Token refreshed successfully');
-        return accessToken;
-    }
-    catch (error) {
-        console.error('Failed to refresh access token:', error);
-        console.log('Please run "dotrequirements login" to re-authenticate.');
-        return null;
-    }
-}
-/**
- * Ensure user is authenticated with a valid access token.
- *
- * Throws an error if not logged in or if token refresh fails.
- * Use this at the start of commands that require authentication.
- */
-export async function requireAuth() {
-    const accessToken = await getValidAccessToken();
-    if (!accessToken) {
-        throw new Error('Not authenticated. Please run "dotrequirements login" first.');
-    }
-    return accessToken;
-}
-//# sourceMappingURL=token-refresh.js.map

package/dist/utils/token-storage.d.ts

@@ -1,31 +0,0 @@
-/**
- * Token storage utilities for OAuth access tokens and refresh tokens.
- *
- * Uses file-based storage at ~/.dotrequirements/tokens.json with restricted permissions.
- */
-export interface StoredTokens {
-    accessToken: string;
-    refreshToken: string;
-    expiresAt: number;
-}
-/**
- * Store tokens in file storage with restricted permissions
- */
-export declare function storeTokens(tokens: StoredTokens): Promise<void>;
-/**
- * Retrieve stored tokens from file
- */
-export declare function getTokens(): Promise<StoredTokens | null>;
-/**
- * Delete stored tokens
- */
-export declare function deleteTokens(): Promise<void>;
-/**
- * Check if tokens are expired
- */
-export declare function areTokensExpired(tokens: StoredTokens): boolean;
-/**
- * Check if tokens exist and are valid
- */
-export declare function hasValidTokens(): Promise<boolean>;
-//# sourceMappingURL=token-storage.d.ts.map

package/dist/utils/token-storage.js

@@ -1,57 +0,0 @@
-/**
- * Token storage utilities for OAuth access tokens and refresh tokens.
- *
- * Uses file-based storage at ~/.dotrequirements/tokens.json with restricted permissions.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-const TOKEN_DIR = path.join(os.homedir(), '.dotrequirements');
-const TOKEN_FILE = path.join(TOKEN_DIR, 'tokens.json');
-/**
- * Store tokens in file storage with restricted permissions
- */
-export async function storeTokens(tokens) {
-    if (!fs.existsSync(TOKEN_DIR)) {
-        fs.mkdirSync(TOKEN_DIR, { recursive: true, mode: 0o700 });
-    }
-    fs.writeFileSync(TOKEN_FILE, JSON.stringify(tokens, null, 2), { mode: 0o600 });
-}
-/**
- * Retrieve stored tokens from file
- */
-export async function getTokens() {
-    if (fs.existsSync(TOKEN_FILE)) {
-        try {
-            const content = fs.readFileSync(TOKEN_FILE, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            console.error('Failed to read stored tokens:', error);
-            return null;
-        }
-    }
-    return null;
-}
-/**
- * Delete stored tokens
- */
-export async function deleteTokens() {
-    if (fs.existsSync(TOKEN_FILE)) {
-        fs.unlinkSync(TOKEN_FILE);
-    }
-}
-/**
- * Check if tokens are expired
- */
-export function areTokensExpired(tokens) {
-    return Date.now() >= tokens.expiresAt;
-}
-/**
- * Check if tokens exist and are valid
- */
-export async function hasValidTokens() {
-    const tokens = await getTokens();
-    return tokens !== null && !areTokensExpired(tokens);
-}
-//# sourceMappingURL=token-storage.js.map