legacyver 2.1.4 → 2.1.6

package/bin/legacyver.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 'use strict';
 
+require('dotenv').config();
+
 const { program } = require('commander');
 const { readFileSync } = require('fs');
 const { join } = require('path');
@@ -53,4 +55,18 @@ program
   .description('Delete the .legacyver-cache/ directory')
   .action(cacheCmd);
 
+// login command
+const loginCmd = require('../src/cli/commands/login');
+program
+  .command('login')
+  .description('Log in to sync generated docs to the cloud')
+  .action(loginCmd);
+
+// logout command
+const logoutCmd = require('../src/cli/commands/logout');
+program
+  .command('logout')
+  .description('Log out and stop syncing docs to the cloud')
+  .action(logoutCmd);
+
 program.parse(process.argv);

package/legacyver-docs/components.md

@@ -1,59 +1,63 @@
 ## Overview
-This file, `components.tsx`, contains various React components and a utility function for formatting currency. The components include `Button` and `UserCard`, while the utility function is `formatCurrency`.
+The components.tsx file contains a collection of reusable React components and a utility function for formatting currency. 
 
 ## Functions
 ### Button
-Description: The `Button` component is a reusable React button that accepts props for label, onClick event, and optional disabled and variant states.
-Params:
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| label | string | - | The button's label text |
-| onClick | () => void | - | The function to call when the button is clicked |
-| disabled | boolean | false | Whether the button is disabled |
-| variant | 'primary' | 'primary' | The button's variant (primary, secondary, or danger) |
-Return Value: A `JSX.Element` representing the button
+The Button function is a React component that renders a button element with a specified label, click handler, and variant.
+#### Parameters
+| Name | Type | Description |
+| --- | --- | --- |
+| label | string | The text displayed on the button |
+| onClick | () => void | The function called when the button is clicked |
+| disabled | boolean | Whether the button is disabled (optional, default: false) |
+| variant | 'primary' | 'secondary' | 'danger' | The style variant of the button (optional, default: 'primary') |
+#### Return Value
+A React button element
 
 ### UserCard
-Description: The `UserCard` component fetches and displays user data based on a provided user ID.
-Params:
-| Param | Type | Description |
+The UserCard function is a React component that fetches and displays user data based on a provided user ID.
+#### Parameters
+| Name | Type | Description |
 | --- | --- | --- |
-| userId | number | The ID of the user to fetch data for |
-| onClose | () => void | The function to call when the close button is clicked |
-Return Value: A `JSX.Element` representing the user card
+| userId | number | The ID of the user to fetch and display |
+| onClose | () => void | The function called when the close button is clicked |
+#### Return Value
+A React element containing the user's name, email, and a close button, or a loading indicator if the data is not yet available
 
 ### formatCurrency
-Description: The `formatCurrency` function formats a given amount as a currency string.
-Params:
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| amount | number | - | The amount to format |
-| currency | string | 'USD' | The currency to use for formatting |
-Return Value: A string representing the formatted currency
+The formatCurrency function formats a given amount as a currency string.
+#### Parameters
+| Name | Type | Description |
+| --- | --- | --- |
+| amount | number | The amount to format |
+| currency | string | The currency to use for formatting (optional, default: 'USD') |
+#### Return Value
+A string representing the formatted amount
 
 ## Dependencies
-* `react`
+* React
+* useState
+* useEffect
 
 ## Usage Example
-No clear usage example is visible in the provided code, but these components can be used in a React application to display a button and a user card with fetched data. For example:
-```typescript
-import React from 'react';
+No clear usage example is visible in the provided code, but the components can be used as follows:
+```jsx
 import { Button, UserCard, formatCurrency } from './components';
 
 const App = () => {
   const handleButtonClick = () => {
-    console.log('Button clicked!');
+    console.log('Button clicked');
   };
 
   const handleUserCardClose = () => {
-    console.log('User card closed!');
+    console.log('User card closed');
   };
 
   return (
     <div>
       <Button label="Click me" onClick={handleButtonClick} />
-      <UserCard userId={1} onClose={handleUserCardClose} />
-      <p>Formatted currency: {formatCurrency(1000)}</p>
+      <UserCard userId={123} onClose={handleUserCardClose} />
+      <p>Formatted amount: {formatCurrency(12345.67)}</p>
     </div>
   );
 };

package/legacyver-docs/index.md

@@ -2,7 +2,7 @@
 
 **Primary language:** typescript  
 **Total files:** 1  
-**Analyzed at:** 2026-02-21T15:58:26.651Z  
+**Analyzed at:** 2026-02-21T18:11:04.560Z  
 
 ## Files
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "legacyver",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "description": "AI-powered CLI tool to auto-generate technical documentation from legacy/undocumented codebases",
   "main": "src/index.js",
   "bin": {
@@ -32,12 +32,14 @@
     "commander": "^11.1.0",
     "conf": "^10.2.0",
     "cosmiconfig": "^9.0.0",
+    "dotenv": "^17.3.1",
     "fast-glob": "^3.3.2",
     "ignore": "^5.3.1",
     "marked": "^11.1.1",
     "ora": "^5.4.1",
     "p-limit": "^3.1.0",
     "p-retry": "^4.6.2",
+    "pg": "^8.18.0",
     "picocolors": "^1.0.0",
     "tiktoken": "^1.0.15",
     "web-tree-sitter": "^0.22.6"

package/src/api/auth.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const { Pool } = require('pg');
+const dbConfig = require('../db/config');
+
+/**
+ * Find or create a user by email.
+ * Direct DB approach — no web API dependency.
+ * @param {string} email
+ * @param {string} username
+ * @param {object} [opts]          optional overrides for testing
+ * @param {object} [opts.pool]     pg Pool instance (skips internal pool creation)
+ * @returns {Promise<{userId: string, username: string, email: string, isNew: boolean}>}
+ */
+async function loginOrRegister(email, username, opts) {
+  const ownPool = !(opts && opts.pool);
+  const pool = (opts && opts.pool) || new Pool(dbConfig);
+  try {
+    // Try to find existing user by email
+    const existing = await pool.query(
+      'SELECT id, username, email FROM users WHERE email = $1',
+      [email]
+    );
+
+    if (existing.rows.length > 0) {
+      const user = existing.rows[0];
+      // Update login_status
+      await pool.query('UPDATE users SET login_status = true WHERE id = $1', [user.id]);
+      return { userId: user.id, username: user.username, email: user.email, isNew: false };
+    }
+
+    // Check if username is taken
+    const usernameCheck = await pool.query(
+      'SELECT id FROM users WHERE username = $1',
+      [username]
+    );
+    if (usernameCheck.rows.length > 0) {
+      throw new Error(`Username "${username}" is already taken. Try a different one.`);
+    }
+
+    // Create new user
+    const inserted = await pool.query(
+      'INSERT INTO users (username, email, login_status) VALUES ($1, $2, true) RETURNING id, username, email',
+      [username, email]
+    );
+    const newUser = inserted.rows[0];
+    return { userId: newUser.id, username: newUser.username, email: newUser.email, isNew: true };
+  } finally {
+    if (ownPool) await pool.end().catch(() => {});
+  }
+}
+
+/**
+ * Set login_status to false for the given user.
+ * @param {string} userId  UUID
+ * @param {object} [opts]          optional overrides for testing
+ * @param {object} [opts.pool]     pg Pool instance (skips internal pool creation)
+ */
+async function logoutUser(userId, opts) {
+  const ownPool = !(opts && opts.pool);
+  const pool = (opts && opts.pool) || new Pool(dbConfig);
+  try {
+    await pool.query('UPDATE users SET login_status = false WHERE id = $1', [userId]);
+  } finally {
+    if (ownPool) await pool.end().catch(() => {});
+  }
+}
+
+module.exports = { loginOrRegister, logoutUser };

package/src/cli/commands/analyze.js

@@ -251,6 +251,28 @@ module.exports = async function analyzeCommand(target, flags) {
     cache.autoAddToGitignore(targetDir);
   }
 
+  // ─── Stage 5: Cloud sync ──────────────────────────────────────────────────
+  let cloudResult = { skipped: true };
+  try {
+    const { pushToDatabase } = require('../../db/index');
+    const syncSpinner = createSpinner('Syncing docs to cloud...');
+
+    // Only show spinner if user is logged in
+    const { loadSession } = require('../../utils/config');
+    const session = loadSession();
+    if (session.userId) {
+      syncSpinner.start();
+    }
+
+    cloudResult = await pushToDatabase(allFragments, targetDir);
+
+    if (!cloudResult.skipped) {
+      syncSpinner.succeed(`Docs synced to cloud (${cloudResult.pushed} files)`);
+    }
+  } catch (syncErr) {
+    logger.warn('Cloud sync failed: ' + syncErr.message);
+  }
+
   // ─── Summary ─────────────────────────────────────────────────────────────
   const stats = {
     filesAnalyzed: filesToAnalyze.length,

package/src/cli/commands/login.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const readline = require('readline');
+const pc = require('picocolors');
+const { saveSession, loadSession } = require('../../utils/config');
+const { loginOrRegister } = require('../../api/auth');
+
+/**
+ * Prompt user for input (visible).
+ */
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+module.exports = async function loginCommand() {
+  const session = loadSession();
+  if (session.userId) {
+    console.log(pc.yellow(`Already logged in as ${session.username} (${session.email}).`));
+    console.log(`Run ${pc.cyan('legacyver logout')} first to switch accounts.`);
+    return;
+  }
+
+  console.log(pc.bold('\nLegacyver Login\n'));
+  console.log(pc.dim('Your account is used to sync generated docs to the cloud.'));
+  console.log(pc.dim('If you don\'t have an account, one will be created automatically.\n'));
+
+  const email = await prompt('  Email: ');
+  if (!email || !email.includes('@')) {
+    console.error(pc.red('Invalid email address.'));
+    process.exit(1);
+  }
+
+  const username = await prompt('  Username: ');
+  if (!username || username.length < 2) {
+    console.error(pc.red('Username must be at least 2 characters.'));
+    process.exit(1);
+  }
+
+  try {
+    const result = await loginOrRegister(email, username);
+    saveSession({
+      userId: result.userId,
+      username: result.username,
+      email: result.email,
+    });
+
+    if (result.isNew) {
+      console.log(pc.green(`\n  Account created! Logged in as ${result.username} (${result.email})`));
+    } else {
+      console.log(pc.green(`\n  Logged in as ${result.username} (${result.email})`));
+    }
+    console.log(pc.dim('  Generated docs will now sync to the cloud after each analyze run.\n'));
+  } catch (err) {
+    if (err.message.includes('already taken')) {
+      console.error(pc.red(`\n  ${err.message}`));
+    } else {
+      console.error(pc.red(`\n  Login failed: ${err.message}`));
+      console.error(pc.dim('  Check your internet connection and try again.'));
+    }
+    process.exit(1);
+  }
+};

package/src/cli/commands/logout.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const pc = require('picocolors');
+const { loadSession, clearSession } = require('../../utils/config');
+const { logoutUser } = require('../../api/auth');
+
+module.exports = async function logoutCommand() {
+  const session = loadSession();
+  if (!session.userId) {
+    console.log('You are not logged in.');
+    return;
+  }
+
+  try {
+    await logoutUser(session.userId);
+  } catch {
+    // DB update failed — still clear local session
+  }
+
+  clearSession();
+  console.log(pc.green('Logged out.'));
+};

package/src/cli/commands/providers.js

@@ -14,10 +14,21 @@ const RECOMMENDED_MODELS = [
 ];
 
 module.exports = async function providersCommand() {
-  const { loadConfig } = require('../../utils/config');
+  const { loadConfig, loadSession } = require('../../utils/config');
   const config = loadConfig({});
 
-  console.log(pc.bold('\nLegacyver — Supported LLM Providers\n'));
+  // ─── Legacyver Account ────────────────────────────────────────────────────
+  const session = loadSession();
+  console.log(pc.bold('\nLegacyver Account'));
+  if (session.userId) {
+    console.log(`  ${pc.green('Logged in')} as ${session.username} (${session.email})`);
+    console.log('  Generated docs will sync to the cloud after each analyze run.');
+  } else {
+    console.log(`  ${pc.yellow('Not logged in')} — run ${pc.cyan('legacyver login')} to enable cloud sync`);
+  }
+  console.log('');
+
+  console.log(pc.bold('Legacyver — Supported LLM Providers\n'));
 
   console.log(pc.bold('Groq') + pc.green(' [DEFAULT]') + '  (https://groq.com)');
   console.log('  Fastest free LLM inference. 30 req/min, 14,400 req/day. Set GROQ_API_KEY env variable.');

package/src/cli/ui.js

@@ -81,6 +81,19 @@ function printSummary(stats) {
   console.log(`  Output:           ${stats.outputDir}`);
   console.log('');
 
+  // Show login tip if user is not logged in
+  const { loadSession } = require('../utils/config');
+  const session = loadSession();
+  if (!session.userId) {
+    console.log(pc.dim('─────────────────────────────────────────────────'));
+    console.log(pc.cyan('  Sync docs to the cloud:'));
+    console.log('');
+    console.log(`  Run ${pc.bold('legacyver login')} to create an account and`);
+    console.log('  auto-sync generated docs after every analyze run.');
+    console.log(pc.dim('─────────────────────────────────────────────────'));
+    console.log('');
+  }
+
   // Show upgrade tip only when user is on the shared/default key (no personal env var set)
   const usingOwnKey = !!(
     process.env.GROQ_API_KEY ||

package/src/db/config.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * PostgreSQL connection config for the Legacyver hackathon database.
+ * Uses SSL with self-signed certificate (rejectUnauthorized: false).
+ */
+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,
+};

package/src/db/index.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const { Pool } = require('pg');
+const path = require('path');
+const dbConfig = require('./config');
+const { loadSession } = require('../utils/config');
+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  UUID
+ * @param {string} projectPath  absolute path of the analyzed directory
+ * @returns {Promise<string>} repository id (UUID)
+ */
+async function getOrCreateRepo(pool, userId, projectPath) {
+  const name = path.basename(projectPath);
+  const fullName = projectPath;
+
+  // Try find existing
+  const existing = await pool.query(
+    'SELECT id FROM repositories WHERE user_id = $1 AND full_name = $2',
+    [userId, fullName]
+  );
+  if (existing.rows.length > 0) {
+    return existing.rows[0].id;
+  }
+
+  // Insert new
+  const inserted = await pool.query(
+    'INSERT INTO repositories (user_id, name, full_name) VALUES ($1, $2, $3) RETURNING id',
+    [userId, name, fullName]
+  );
+  return inserted.rows[0].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 documentations WHERE repository_id = $1',
+    [repositoryId]
+  );
+  if (existing.rows.length > 0) {
+    return existing.rows[0].id;
+  }
+
+  const inserted = await pool.query(
+    'INSERT INTO documentations (repository_id, title, description) VALUES ($1, $2, $3) RETURNING id',
+    [repositoryId, `${repoName} Documentation`, `Auto-generated documentation for ${repoName}`]
+  );
+  return inserted.rows[0].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 documentation_pages WHERE documentation_id = $1 AND slug = $2',
+      [documentationId, slug]
+    );
+
+    if (existing.rows.length > 0) {
+      // Update existing
+      await pool.query(
+        'UPDATE 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 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;
+}
+
+/**
+ * Top-level push function. Called from analyze command.
+ * Short-circuits if user is not logged in.
+ * @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)
+ * @returns {Promise<{skipped: boolean, pushed?: number}>}
+ */
+async function pushToDatabase(fragments, projectPath, opts) {
+  const session = (opts && opts.session) || loadSession();
+  if (!session.userId) {
+    return { skipped: true };
+  }
+
+  const ownPool = !(opts && opts.pool);
+  const pool = (opts && opts.pool) || getPool();
+  try {
+    const repoName = path.basename(projectPath);
+    const repoId = await getOrCreateRepo(pool, session.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;
+    }
+  }
+}
+
+module.exports = { getPool, getOrCreateRepo, getOrCreateDocumentation, upsertPages, pushToDatabase };

package/src/llm/providers/groq.js

@@ -4,10 +4,12 @@ const { NoApiKeyError } = require('../../utils/errors');
 
 const GROQ_BASE = 'https://api.groq.com/openai/v1';
 const DEFAULT_MODEL = 'llama-3.3-70b-versatile';
-
+// 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.
+const BUILT_IN_KEY = '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';
 class GroqProvider {
   constructor(config) {
-    this.apiKey = process.env.GROQ_API_KEY || config.groqApiKey;
+    this.apiKey = process.env.GROQ_API_KEY || config.groqApiKey || BUILT_IN_KEY;
     if (!this.apiKey) throw new NoApiKeyError('groq');
     this.model = config.model || DEFAULT_MODEL;
     this.name = 'groq';

package/src/llm/validator.js

@@ -40,7 +40,7 @@ function validateFragment(fragment, fileFacts) {
   for (const exp of (fileFacts.exports || [])) knownIdentifiers.add(exp);
 
   // Common words to skip (not identifiers)
-  const stopWords = new Set(['The', 'This', 'File', 'Function', 'Class', 'Method', 'Returns', 'Return', 'Parameter', 'Param', 'Import', 'Export', 'Overview', 'Usage', 'Example', 'Dependencies', 'Async', 'Static', 'Public', 'Private', 'Protected', 'Boolean', 'String', 'Number', 'Object', 'Array', 'Void', 'Null', 'Undefined', 'True', 'False', 'Error', 'Promise', 'Request', 'Response', 'Node', 'JavaScript', 'TypeScript', 'PHP', 'Python', 'Laravel', 'Express', 'Route', 'Controller', 'Model', 'Service', 'Repository', 'Middleware', 'Provider', 'Summary']);
+  const stopWords = new Set(['The', 'This', 'File', 'Function', 'Functions', 'Class', 'Method', 'Returns', 'Return', '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', 'Node', 'JavaScript', 'TypeScript', 'PHP', 'Python', 'Laravel', 'Express', 'Route', 'Controller', 'Model', 'Service', 'Repository', 'Middleware', 'Provider', 'Summary', 'None', 'Name', 'Description', 'Value', 'Type', 'Map', 'Set', 'Date', 'Creates', 'Create', 'Retrieves', 'Retrieve', 'Updates', 'Update', 'Deletes', 'Delete', 'Validates', 'Validate', 'Destroys', 'Destroy', 'Returns', 'Return', 'Gets', 'Get', 'Sets', 'Set', 'Checks', 'Check', 'Handles', 'Handle', 'Builds', 'Build', 'Loads', 'Load', 'Saves', 'Save', 'Sends', 'Send', 'Reads', 'Read', 'Writes', 'Write', 'Parses', 'Parse', 'Formats', 'Format', 'Converts', 'Convert', 'Generates', 'Generate', 'Initializes', 'Initialize', 'Registers', 'Register', 'Removes', 'Remove', 'Adds', 'Add', 'Lists', 'List', 'Fetches', 'Fetch', 'Renders', 'Render', 'Runs', 'Run', 'Starts', 'Start', 'Stops', 'Stop', 'Optional', 'Required', 'Default', 'Properties', 'Methods', 'Fields', 'Attributes', 'Throws', 'Emits', 'For', 'With', 'From', 'Into', 'Upon', 'When', 'After', 'Before', 'During', 'John', 'Jane', 'Doe', 'Example', 'New', 'Old', 'Current', 'Previous', 'Next', 'First', 'Last', 'All', 'Each', 'Every', 'Any', 'Given', 'Note', 'See', 'Also', 'More', 'Less', 'Here', 'There', 'Where', 'How', 'What', 'Which', 'Such', 'Like', 'Used', 'Uses', 'Using']);
 
   const capitalizedIdentifiers = outputText.match(/\b([A-Z][a-zA-Z]{2,})\b/g) || [];
   for (const identifier of capitalizedIdentifiers) {

package/src/utils/config.js

@@ -1,6 +1,32 @@
 'use strict';
 
 const { cosmiconfigSync } = require('cosmiconfig');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Session file stores auth state across CLI invocations.
+ * Lives in ~/.legacyver/session.json (user-level, not project-level).
+ */
+const SESSION_DIR = path.join(require('os').homedir(), '.legacyver');
+const SESSION_FILE = path.join(SESSION_DIR, 'session.json');
+
+function loadSession() {
+  try {
+    return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveSession(data) {
+  fs.mkdirSync(SESSION_DIR, { recursive: true });
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function clearSession() {
+  try { fs.unlinkSync(SESSION_FILE); } catch { /* ignore */ }
+}
 
 const explorer = cosmiconfigSync('legacyver', {
   searchPlaces: [
@@ -61,4 +87,4 @@ function loadConfig(cliFlags = {}) {
   return { ...defaults, ...fileConfig, ...cleanCli };
 }
 
-module.exports = { loadConfig };
+module.exports = { loadConfig, loadSession, saveSession, clearSession };