legacyver 3.2.0 → 3.4.1

package/legacyver-docs/OrderController.md

@@ -0,0 +1,80 @@
+## Overview
+This is the `OrderController` class, responsible for handling CRUD (Create, Read, Update, Delete) operations on orders. It provides a RESTful API interface to interact with the order data.
+
+## Functions
+
+### index
+#### Description
+Returns a paginated list of orders.
+#### Parameters
+| Parameter | Type | Required |
+| --- | --- | --- |
+| `paginate` | int | - |
+| `response` | object | - |
+| `json` | function | - |
+
+#### Return Value
+A `JsonResponse` containing the paginated list of orders.
+
+### store
+#### Description
+Creates a new order and returns its details.
+#### Parameters
+| Parameter | Type | Required |
+| --- | --- | --- |
+| `$request:StoreOrderRequest` | object | Yes |
+
+#### Return Value
+A `JsonResponse` with the created order data and HTTP status code 201.
+
+### show
+#### Description
+Returns a single order by its ID.
+#### Parameters
+| Parameter | Type | Required |
+| --- | --- | --- |
+| `$id:int` | int | Yes |
+
+#### Return Value
+A `JsonResponse` containing the order details.
+
+### update
+#### Description
+Updates an existing order.
+#### Parameters
+| Parameter | Type | Required |
+| --- | --- | --- |
+| `$request:UpdateOrderRequest` | object | Yes |
+| `$id:int` | int | Yes |
+
+#### Return Value
+A `JsonResponse` with the updated order data.
+
+### destroy
+#### Description
+Deletes an existing order.
+#### Parameters
+| Parameter | Type | Required |
+| --- | --- | --- |
+| `$id:int` | int | Yes |
+
+#### Return Value
+A `JsonResponse` with HTTP status code 204.
+
+## Dependencies
+
+* `App\Models\Order`
+* `App\Models\User`
+* `App\Http\Requests\StoreOrderRequest`
+* `App\Http\Requests\UpdateOrderRequest`
+* `App\Services\OrderService`
+* `Illuminate\Http\JsonResponse`
+
+## Usage Example
+```php
+$orderController = new OrderController();
+$orders = $orderController->index(); // returns paginated list of orders
+
+$order = $orderController->store(new StoreOrderRequest(['name' => 'New Order'])); // creates and returns order details
+```
+Note: The usage example is just a demonstration and should be replaced with actual usage scenarios.

package/legacyver-docs/SUMMARY.md

@@ -1,3 +1,3 @@
-# Summary
-
-* [legacyver.js](legacyver.md)
+# Summary
+
+* [OrderController.php](OrderController.md)

package/legacyver-docs/auth.md

@@ -0,0 +1,71 @@
+## Overview
+`auth.js` provides two asynchronous helpers for handling CLI session tokens stored in the `user_sessions` table: validating a token and revoking (logging out) a token.
+
+## Functions
+
+### `validateToken(token)`
+Validates a raw CLI session token and returns basic user information if the token is active.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `token` | `string` | Raw token read from `~/.legacyver/session.json`. |
+
+**Returns**  
+`Promise<{ userId: string, username: string, email: string } | null>` – Resolves to an object containing the user’s ID, username, and email when the token is found, not expired, and not revoked; otherwise resolves to `null`.
+
+**Logic summary**
+1. If `token` is falsy, the function returns `null` immediately.  
+2. The token is hashed with SHA‑256 (`crypto.createHash('sha256')`).  
+3. A database client is created via `createDbClient(token)` – the token is passed so the client can bypass row‑level security.  
+4. The client queries the `public.user_sessions` table, selecting `user_id` and the related `users` fields `username` and `email` (inner join).  
+5. The query filters:  
+   * `token_hash` equals the computed hash,  
+   * `expires_at` is greater than the current ISO timestamp,  
+   * `revoked_at` is `null`.  
+6. `maybeSingle()` ensures at most one row is returned.  
+7. If the query yields an error or no data, the function returns `null`.  
+8. Otherwise it builds the result object, converting `user_id` to a string and falling back to default values (`'unknown'` for username, empty string for email) if the joined user record is missing.
+
+---
+
+### `revokeToken(token)`
+Revokes a CLI session token, effectively logging the user out.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `token` | `string` | Raw token to be revoked. |
+
+**Returns**  
+`Promise<void>` – Resolves when the revocation update completes; throws an error if the database operation fails.
+
+**Logic summary**
+1. If `token` is falsy, the function exits without action.  
+2. The token is hashed with SHA‑256 (same method as `validateToken`).  
+3. A database client is created with `createDbClient(token)`.  
+4. The client updates the `revoked_at` column of the matching `user_sessions` row (where `token_hash` matches) to the current ISO timestamp.  
+5. If the update returns an `error`, the function throws that error; otherwise it completes silently.
+
+## Dependencies
+- `crypto` (Node.js built‑in) – used for SHA‑256 hashing.  
+- `../db/config` – imports `supabase` (unused in this file) and `createDbClient` for database access.
+
+## Usage Example
+```js
+const { validateToken, revokeToken } = require('./auth');
+
+// Validate a stored session token
+(async () => {
+  const token = 'my‑raw‑session‑token';
+  const user = await validateToken(token);
+
+  if (user) {
+    console.log('Authenticated user:', user);
+  } else {
+    console.log('Invalid or expired token');
+  }
+
+  // When the user logs out
+  await revokeToken(token);
+  console.log('Token revoked');
+})();
+```

package/legacyver-docs/hash.md

@@ -0,0 +1,37 @@
+## Overview
+Provides a utility to compute the SHA‑256 hash of a file's contents, returning the hash as a hex string prefixed with `sha256:`.
+
+## Functions
+
+### `computeHash(filePath)`
+Computes the SHA‑256 hash of the file located at `filePath`.
+
+| Parameter | Type   | Description                |
+|-----------|--------|----------------------------|
+| `filePath`| string | Path to the file to hash.  |
+
+**Returns**: `string` – A hexadecimal SHA‑256 digest prefixed with `sha256:` (e.g., `sha256:ab12cd...`).
+
+**Logic**  
+1. Reads the file synchronously using `fs.readFileSync`.  
+2. Creates a SHA‑256 hash object via `crypto.createHash('sha256')`.  
+3. Feeds the file content to the hash with `.update(content)`.  
+4. Produces a hex‑encoded digest with `.digest('hex')`.  
+5. Concatenates the prefix `sha256:` with the digest and returns the result.
+
+## Dependencies
+- `crypto` – `createHash`
+- `fs` – `readFileSync`
+
+## Usage Example
+```javascript
+// Import the function
+const { computeHash } = require('./hash');
+
+// Compute the hash of a file
+const filePath = 'path/to/your/file.txt';
+const hash = computeHash(filePath);
+
+console.log(`SHA-256 hash: ${hash}`);
+// Example output: SHA-256 hash: sha256:3a7bd3e2360a... 
+```

package/legacyver-docs/index.md

@@ -1,15 +1,15 @@
-# bin — Documentation
-
-**Primary language:** javascript  
-**Total files:** 1  
-**Analyzed at:** 2026-03-21T11:31:12.941Z  
-
-## Files
-
-- [legacyver.js](legacyver.md)
-
-## Dependency Graph
-
-```mermaid
-graph TD
-```
+# Controllers — Documentation
+
+**Primary language:** php  
+**Total files:** 1  
+**Analyzed at:** 2026-02-22T03:45:37.186Z  
+
+## Files
+
+- [OrderController.php](OrderController.md)
+
+## Dependency Graph
+
+```mermaid
+graph TD
+```

package/package.json

@@ -1,8 +1,16 @@
 {
   "name": "legacyver",
-  "version": "3.2.0",
+  "version": "3.4.1",
   "description": "AI-powered CLI tool to auto-generate technical documentation from legacy/undocumented codebases",
   "main": "src/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dhnillhaq/Legacyver-Node-Package.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Dhnillhaq/Legacyver-Node-Package/issues"
+  },
+  "homepage": "https://github.com/Dhnillhaq/Legacyver-Node-Package#readme",
   "bin": {
     "legacyver": "bin/legacyver.js"
   },
@@ -27,6 +35,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@supabase/supabase-js": "^2.99.3",
     "chalk": "^4.1.2",
     "cli-progress": "^3.12.0",
     "commander": "^11.1.0",
@@ -47,4 +56,4 @@
     "eslint": "^8.57.0",
     "vitest": "^1.2.2"
   }
-}
+}

package/src/api/auth.js

@@ -1,69 +1,56 @@
 'use strict';
 
 const crypto = require('crypto');
-const { Pool } = require('pg');
-const dbConfig = require('../db/config');
+const { supabase, createDbClient } = require('../db/config');
 
 /**
  * Validate a CLI session token against app.user_sessions.
  * Returns user info if valid, null if expired/revoked/not found.
  *
  * @param {string} token  raw token from ~/.legacyver/session.json
- * @param {object} [opts]          optional overrides for testing
- * @param {object} [opts.pool]     pg Pool instance
  * @returns {Promise<{userId: string, username: string, email: string} | null>}
  */
-async function validateToken(token, opts) {
+async function validateToken(token) {
   if (!token) return null;
 
-  const ownPool = !(opts && opts.pool);
-  const pool = (opts && opts.pool) || new Pool(dbConfig);
-  try {
-    const tokenHash = crypto.createHash('sha256').update(token).digest('hex');
-
-    const result = await pool.query(
-      `SELECT s.user_id, u.username, u.email
-       FROM app.user_sessions s
-       JOIN app.users u ON u.id = s.user_id
-       WHERE s.token_hash = $1
-         AND s.expires_at > NOW()
-         AND s.revoked_at IS NULL`,
-      [tokenHash]
-    );
-
-    if (result.rows.length === 0) return null;
-
-    const row = result.rows[0];
-    return {
-      userId: String(row.user_id),
-      username: row.username || 'unknown',
-      email: row.email || '',
-    };
-  } finally {
-    if (ownPool) await pool.end().catch(() => {});
-  }
+  const tokenHash = crypto.createHash('sha256').update(token).digest('hex');
+  const client = createDbClient(token); // Use token to bypass RLS
+
+  const { data, error } = await client
+    .schema('public')
+    .from('user_sessions')
+    .select('user_id, users!inner(username, email)')
+    .eq('token_hash', tokenHash)
+    .gt('expires_at', new Date().toISOString())
+    .is('revoked_at', null)
+    .maybeSingle();
+
+  if (error || !data) return null;
+
+  return {
+    userId: String(data.user_id),
+    username: data.users?.username || 'unknown',
+    email: data.users?.email || '',
+  };
 }
 
 /**
  * Revoke a CLI session token (logout).
  * @param {string} token  raw token
- * @param {object} [opts]          optional overrides for testing
- * @param {object} [opts.pool]     pg Pool instance
  */
-async function revokeToken(token, opts) {
+async function revokeToken(token) {
   if (!token) return;
 
-  const ownPool = !(opts && opts.pool);
-  const pool = (opts && opts.pool) || new Pool(dbConfig);
-  try {
-    const tokenHash = crypto.createHash('sha256').update(token).digest('hex');
-    await pool.query(
-      'UPDATE app.user_sessions SET revoked_at = NOW() WHERE token_hash = $1',
-      [tokenHash]
-    );
-  } finally {
-    if (ownPool) await pool.end().catch(() => {});
-  }
+  const tokenHash = crypto.createHash('sha256').update(token).digest('hex');
+  const client = createDbClient(token);
+
+  const { error } = await client
+    .schema('public')
+    .from('user_sessions')
+    .update({ revoked_at: new Date().toISOString() })
+    .eq('token_hash', tokenHash);
+
+  if (error) throw error;
 }
 
 module.exports = { validateToken, revokeToken };

package/src/cli/commands/analyze.js

@@ -217,7 +217,23 @@ module.exports = async function analyzeCommand(target, flags) {
 
   // Merge cached fragments
   const allFragments = [...docFragments];
-  // (cached fragments would be loaded here)
+  if (config.incremental && cacheHits.length > 0) {
+    const fs = require('fs');
+    for (const hit of cacheHits) {
+      const cachedInfo = cacheMap[hit.relativePath];
+      if (cachedInfo && cachedInfo.docFile) {
+        try {
+          const content = fs.readFileSync(cachedInfo.docFile, 'utf8');
+          allFragments.push({
+            ...hit,
+            content
+          });
+        } catch (e) {
+          logger.warn(`Failed to read cached file for ${hit.relativePath}`);
+        }
+      }
+    }
+  }
 
   // ─── Stage 4: Renderer ───────────────────────────────────────────────────
   const renderSpinner = createSpinner('Rendering output...');
@@ -268,8 +284,11 @@ module.exports = async function analyzeCommand(target, flags) {
 
     if (!cloudResult.skipped) {
       syncSpinner.succeed(`Docs synced to cloud (${cloudResult.pushed} files)`);
+    } else if (session.token) {
+      syncSpinner.stop(); // Stops spinner gracefully if skipped without error
     }
   } catch (syncErr) {
+    if (typeof syncSpinner !== 'undefined') syncSpinner.fail('Cloud sync failed');
     logger.warn('Cloud sync failed: ' + syncErr.message);
   }
 

package/src/cli/commands/login.js

@@ -5,7 +5,7 @@ const crypto = require('crypto');
 const pc = require('picocolors');
 const { saveSession, loadSession } = require('../../utils/config');
 
-const WEB_URL = 'https://weci-holic.hackathon.sev-2.com';
+const WEB_URL = 'https://legac.vercel.app';
 
 /**
  * Open a URL in the default browser (cross-platform).

package/src/db/config.js

@@ -1,18 +1,43 @@
 'use strict';
 
+const { createClient } = require('@supabase/supabase-js');
+
 /**
- * PostgreSQL connection config for the Legacyver hackathon database.
- * Uses SSL with self-signed certificate (rejectUnauthorized: false).
+ * Supabase client for Legacyver CLI.
+ *
+ * Uses the public anon key — safe to bundle in an npm package.
+ * Row Level Security (RLS) on Supabase enforces access control.
  */
-module.exports = {
-  host: '103.185.52.138',
-  port: 1185,
-  user: 'weci_holic',
-  password: 'f==+HLH_bvzLN2fo82f3x239MZE3@bGF',
-  database: 'weci_holic',
-  ssl: { rejectUnauthorized: false },
-  // Keep pool small — CLI is short-lived
-  max: 3,
-  idleTimeoutMillis: 5000,
-  connectionTimeoutMillis: 10000,
-};
+const SUPABASE_URL = 'https://kbsxwyoylwhieoljepxr.supabase.co';
+
+// anon/public key — safe to commit, RLS is the gatekeeper
+const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imtic3h3eW95bHdoaWVvbGplcHhyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzQxMjU4ODksImV4cCI6MjA4OTcwMTg4OX0.GHX8Id1qunhypkN6WurM4UZUgVwrkD_z3bOIJhW2Y7A';
+
+const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+  auth: {
+    persistSession: false,
+    autoRefreshToken: false,
+    detectSessionFromUrl: false,
+  },
+});
+
+/**
+ * Create a Supabase client configured with the CLI token for RLS bypass.
+ */
+function createDbClient(token) {
+  const headers = {};
+  if (token) {
+    headers['x-cli-token'] = token;
+  }
+  
+  return createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+      detectSessionFromUrl: false,
+    },
+    global: { headers }
+  });
+}
+
+module.exports = { supabase, createDbClient };

package/src/db/index.js

@@ -1,114 +1,103 @@
 'use strict';
 
-const { Pool } = require('pg');
 const path = require('path');
-const dbConfig = require('./config');
+const { createDbClient } = require('./config');
 const { loadSession } = require('../utils/config');
 const { validateToken } = require('../api/auth');
 const logger = require('../utils/logger');
 
-let _pool = null;
-
-/**
- * Lazy singleton pool — created on first use, ended after push.
- */
-function getPool() {
-  if (!_pool) {
-    _pool = new Pool(dbConfig);
-  }
-  return _pool;
-}
-
 /**
  * Find or create a repository for the given user + project path.
- * @param {Pool} pool
  * @param {string} userId  app.users.id (BIGINT as string)
  * @param {string} projectPath  absolute path of the analyzed directory
  * @returns {Promise<string>} repository id (UUID)
  */
-async function getOrCreateRepo(pool, userId, projectPath) {
+async function getOrCreateRepo(supabase, userId, projectPath) {
   const name = path.basename(projectPath);
   const fullName = projectPath;
 
   // Try find existing
-  const existing = await pool.query(
-    'SELECT id FROM app.repositories WHERE user_id = $1 AND full_name = $2',
-    [userId, fullName]
-  );
-  if (existing.rows.length > 0) {
-    return existing.rows[0].id;
-  }
+  const { data: existing, error: findErr } = await supabase
+    .schema('public')
+    .from('repositories')
+    .select('id')
+    .eq('user_id', userId)
+    .eq('full_name', fullName)
+    .maybeSingle();
+
+  if (findErr) throw findErr;
+  if (existing) return existing.id;
 
   // Insert new
-  const inserted = await pool.query(
-    'INSERT INTO app.repositories (user_id, name, full_name) VALUES ($1, $2, $3) RETURNING id',
-    [userId, name, fullName]
-  );
-  return inserted.rows[0].id;
+  const { data: inserted, error: insertErr } = await supabase
+    .schema('public')
+    .from('repositories')
+    .insert({ user_id: userId, name, full_name: fullName })
+    .select('id')
+    .single();
+
+  if (insertErr) throw insertErr;
+  return inserted.id;
 }
 
 /**
  * Find or create a documentation record for a repository.
  * One documentation per repository (title = repo name).
- * @param {Pool} pool
  * @param {string} repositoryId  UUID
  * @param {string} repoName
  * @returns {Promise<string>} documentation id (UUID)
  */
-async function getOrCreateDocumentation(pool, repositoryId, repoName) {
-  const existing = await pool.query(
-    'SELECT id FROM app.documentations WHERE repository_id = $1',
-    [repositoryId]
-  );
-  if (existing.rows.length > 0) {
-    return existing.rows[0].id;
-  }
+async function getOrCreateDocumentation(supabase, repositoryId, repoName) {
+  const { data: existing, error: findErr } = await supabase
+    .schema('public')
+    .from('documentations')
+    .select('id')
+    .eq('repository_id', repositoryId)
+    .maybeSingle();
 
-  const inserted = await pool.query(
-    'INSERT INTO app.documentations (repository_id, title, description) VALUES ($1, $2, $3) RETURNING id',
-    [repositoryId, `${repoName} Documentation`, `Auto-generated documentation for ${repoName}`]
-  );
-  return inserted.rows[0].id;
+  if (findErr) throw findErr;
+  if (existing) return existing.id;
+
+  const { data: inserted, error: insertErr } = await supabase
+    .schema('public')
+    .from('documentations')
+    .insert({
+      repository_id: repositoryId,
+      title: `${repoName} Documentation`,
+      description: `Auto-generated documentation for ${repoName}`,
+    })
+    .select('id')
+    .single();
+
+  if (insertErr) throw insertErr;
+  return inserted.id;
 }
 
 /**
  * Upsert documentation pages.
  * Each fragment becomes a page; slug = file path, title = file name.
  * Uses (documentation_id, slug) as the logical unique key.
- * @param {Pool} pool
  * @param {string} documentationId  UUID
  * @param {Array<{relativePath: string, content: string}>} fragments
  * @returns {Promise<number>} count of upserted pages
  */
-async function upsertPages(pool, documentationId, fragments) {
-  let count = 0;
-  for (let i = 0; i < fragments.length; i++) {
-    const frag = fragments[i];
-    const slug = frag.relativePath.replace(/\\/g, '/');
-    const title = path.basename(frag.relativePath);
-
-    // Check if page exists
-    const existing = await pool.query(
-      'SELECT id FROM app.documentation_pages WHERE documentation_id = $1 AND slug = $2',
-      [documentationId, slug]
-    );
-
-    if (existing.rows.length > 0) {
-      // Update existing
-      await pool.query(
-        'UPDATE app.documentation_pages SET content = $1, title = $2, page_order = $3, created_at = NOW() WHERE id = $4',
-        [frag.content, title, i + 1, existing.rows[0].id]
-      );
-    } else {
-      // Insert new
-      await pool.query(
-        'INSERT INTO app.documentation_pages (documentation_id, slug, title, content, page_order) VALUES ($1, $2, $3, $4, $5)',
-        [documentationId, slug, title, frag.content, i + 1]
-      );
-    }
-    count++;
-  }
-  return count;
+async function upsertPages(supabase, documentationId, fragments) {
+  const rows = fragments.map((frag, i) => ({
+    documentation_id: documentationId,
+    slug: frag.relativePath.replace(/\\/g, '/'),
+    title: path.basename(frag.relativePath),
+    content: frag.content,
+    page_order: i + 1,
+    created_at: new Date().toISOString(),
+  }));
+
+  const { error } = await supabase
+    .schema('public')
+    .from('documentation_pages')
+    .upsert(rows, { onConflict: 'documentation_id,slug' });
+
+  if (error) throw error;
+  return rows.length;
 }
 
 /**
@@ -118,7 +107,6 @@ async function upsertPages(pool, documentationId, fragments) {
  * @param {Array<{relativePath: string, content: string}>} fragments
  * @param {string} projectPath  absolute path of the analyzed directory
  * @param {object} [opts]          optional overrides for testing
- * @param {object} [opts.pool]     pg Pool instance (skips singleton pool)
  * @param {object} [opts.session]  session object (skips loadSession)
  * @param {object} [opts.user]     user object (skips validateToken) — { userId, username, email }
  * @returns {Promise<{skipped: boolean, pushed?: number}>}
@@ -138,20 +126,13 @@ async function pushToDatabase(fragments, projectPath, opts) {
     }
   }
 
-  const ownPool = !(opts && opts.pool);
-  const pool = (opts && opts.pool) || getPool();
-  try {
-    const repoName = path.basename(projectPath);
-    const repoId = await getOrCreateRepo(pool, user.userId, projectPath);
-    const docId = await getOrCreateDocumentation(pool, repoId, repoName);
-    const pushed = await upsertPages(pool, docId, fragments);
-    return { skipped: false, pushed };
-  } finally {
-    if (ownPool) {
-      await pool.end().catch(() => {});
-      _pool = null;
-    }
-  }
+  const supabase = createDbClient(session.token);
+
+  const repoName = path.basename(projectPath);
+  const repoId = await getOrCreateRepo(supabase, user.userId, projectPath);
+  const docId = await getOrCreateDocumentation(supabase, repoId, repoName);
+  const pushed = await upsertPages(supabase, docId, fragments);
+  return { skipped: false, pushed };
 }
 
-module.exports = { getPool, getOrCreateRepo, getOrCreateDocumentation, upsertPages, pushToDatabase };
+module.exports = { getOrCreateRepo, getOrCreateDocumentation, upsertPages, pushToDatabase };

package/src/llm/providers/groq.js

@@ -7,7 +7,7 @@ const DEFAULT_MODEL = 'openai/gpt-oss-120b';
 // Built-in shared key — lets users run legacyver out of the box without setup.
 // Users can override with their own GROQ_API_KEY env var for higher rate limits.
 // Groq does NOT auto-revoke keys found in public packages (unlike OpenRouter).
-const BUILT_IN_KEY = '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';
+const BUILT_IN_KEY = 'YOUR_API_KEY_HERE'; // <-- REPLACE WITH YOUR GROQ API KEY BEFORE PUBLISHING
 
 class GroqProvider {
   constructor(config) {

package/src/llm/validator.js

@@ -46,7 +46,7 @@ function validateFragment(fragment, fileFacts) {
     'Parameter', 'Parameters', 'Param', 'Import', 'Export', 'Overview', 'Usage', 'Example',
     'Dependencies', 'Dependency', 'Async', 'Static', 'Public', 'Private', 'Protected',
     'Boolean', 'String', 'Number', 'Object', 'Array', 'Void', 'Null', 'Undefined',
-    'True', 'False', 'Error', 'Promise', 'Request', 'Response',
+  'True', 'False', 'Error', 'Promise', 'Request', 'Response',
     'Node', 'JavaScript', 'TypeScript', 'PHP', 'Python', 'PostgreSQL',
     'Laravel', 'Express', 'Route', 'Controller', 'Model', 'Service', 'Repository',
     'Middleware', 'Provider', 'Summary', 'None', 'Name', 'Description', 'Value', 'Type',

package/legacyver-docs/legacyver.md

@@ -1,49 +0,0 @@
-## Overview
-`legacyver.js` is the entry point for the **legacyver** command‑line interface. It configures the `commander` program, loads the package version, registers all supported sub‑commands (analyze, init, providers, cache, login, logout, push) and parses the command‑line arguments.
-
-## Functions
-The file does not declare any JavaScript functions of its own. It only wires together imported command‑handler functions (e.g., `analyzeCmd`, `initCmd`, …) with the `commander` program.
-
-## Dependencies
-- **commander** – `program` is used to define the CLI, its options, and sub‑commands.  
-- **fs** – `readFileSync` reads `package.json` to obtain the current version.  
-- **path** – `join` builds the path to `package.json`.  
-- **../src/cli/commands/analyze** – handler for the `analyze` command (`analyzeCmd`).  
-- **../src/cli/commands/init** – handler for the `init` command (`initCmd`).  
-- **../src/cli/commands/providers** – handler for the `providers` command (`providersCmd`).  
-- **../src/cli/commands/cache** – handler for the `cache clear` sub‑command (`cacheCmd`).  
-- **../src/cli/commands/login** – handler for the `login` command (`loginCmd`).  
-- **../src/cli/commands/logout** – handler for the `logout` command (`logoutCmd`).  
-- **../src/cli/commands/push** – handler for the `push` command (`pushCmd`).  
-
-## Usage Example
-```bash
-# Show version and help
-legacyver -V
-legacyver --help
-
-# Analyze a codebase and write markdown docs to the default output folder
-legacyver analyze ./src \
-  --out ./legacyver-docs \
-  --format markdown \
-  --provider groq \
-  --concurrency 3
-
-# Run the interactive setup wizard
-legacyver init
-
-# List available LLM providers and models
-legacyver providers
-
-# Clear the incremental analysis cache
-legacyver cache clear
-
-# Log in to the cloud sync service
-legacyver login
-
-# Log out of the cloud sync service
-legacyver logout
-
-# Push already‑generated documentation to the cloud
-legacyver push ./legacyver-docs --out ./legacyver-docs
-```