linage-cli 1.0.0

package/README.md

@@ -0,0 +1,63 @@
+# linage-cli
+
+The Official CLI for Li'nage Cloud - Automate Dependency Discovery & Lineage Mapping.
+
+## Installation
+
+```bash
+npm install -g linage-cli
+```
+
+## Usage
+
+### Login
+
+First, authenticate with your API Key from the Li'nage Cloud dashboard:
+
+```bash
+linage-cli login
+```
+
+### Ingest Dependencies
+
+Scan your current directory and upload your dependency graph:
+
+```bash
+linage-cli ingest
+```
+
+### View Projects
+
+List all projects in your organization:
+
+```bash
+linage-cli projects
+```
+
+### Show Stats
+
+Show organization health metrics:
+
+```bash
+linage-cli stats
+```
+
+### Whoami
+
+Show current authenticated session info:
+
+```bash
+linage-cli whoami
+```
+
+### Open Dashboard
+
+Open your dashboard in the browser:
+
+```bash
+linage-cli open
+```
+
+## License
+
+ISC

package/commands/ingest.js

@@ -0,0 +1,60 @@
+const fs = require('fs');
+const path = require('path');
+const ora = require('ora');
+const api = require('../utils/api');
+const { log } = require('../utils/ui');
+const { detectProject } = require('../utils/scanner');
+
+module.exports = async (options) => {
+  const projectInfo = detectProject();
+  
+  if (!projectInfo) {
+    log.error('No supported dependency file found (package.json, requirements.txt, Cargo.toml).');
+    return;
+  }
+
+  const spinner = ora(`Reading ${projectInfo.file}...`).start();
+  
+  try {
+    const filePath = path.resolve(process.cwd(), projectInfo.file);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    
+    let projectCode = options.project;
+    let version = 'unknown';
+
+    if (projectInfo.type === 'node') {
+        const parsed = JSON.parse(content);
+        projectCode = projectCode || parsed.name;
+        version = parsed.version;
+    } else {
+        // For python/rust, we'll use the directory name as default project code
+        projectCode = projectCode || path.basename(process.cwd());
+    }
+    
+    if (!projectCode) {
+      spinner.fail('Could not determine project name.');
+      log.error('Please specify with --project <name>.');
+      return;
+    }
+
+    spinner.text = `Ingesting ${projectCode} (${projectInfo.type})...`;
+
+    const apiOpts = {};
+    if (options.key) apiOpts.apiKey = options.key;
+
+    const result = await api.post('/api/ingest/cli', {
+      projectCode,
+      fileName: projectInfo.file,
+      ecosystem: projectInfo.type,
+      content
+    }, apiOpts);
+
+    spinner.succeed(`Ingested ${projectCode} successfully!`);
+    if (result.version) log.info(`Version: ${result.version}`);
+    log.dim(`View at: ${require('../utils/config').getApiUrl()}/${result.orgSlug}/projects/${result.projectCode}`);
+
+  } catch (error) {
+    spinner.fail('Ingestion failed.');
+    log.error(error.message);
+  }
+};

package/commands/login.js

@@ -0,0 +1,37 @@
+const inquirer = require('inquirer');
+const ora = require('ora');
+const config = require('../utils/config');
+const api = require('../utils/api');
+const { log, printBox } = require('../utils/ui');
+
+module.exports = async () => {
+  log.info("To get started, you need an API Key from your Li'nage Cloud dashboard.");
+  
+  const answers = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: 'Paste your API Key:',
+      validate: (input) => input.length > 5 || 'API Key seems too short.'
+    }
+  ]);
+
+  const spinner = ora('Verifying API Key...').start();
+
+  try {
+    const isValid = await api.validateKey(answers.apiKey);
+    
+    if (isValid && isValid.success) {
+      config.setApiKey(answers.apiKey);
+      spinner.succeed('Authentication successful!');
+      printBox(`Logged in as:\nOrganization: ${isValid.organization.name} (${isValid.organization.slug})\nKey Name: ${isValid.keyName}`);
+    } else {
+      spinner.fail('Invalid API Key.');
+      log.error('Please check your key and try again.');
+    }
+  } catch (error) {
+    spinner.fail('Connection failed.');
+    log.error(error.message);
+  }
+};
+

package/commands/logout.js

@@ -0,0 +1,7 @@
+const config = require('../utils/config');
+const { log } = require('../utils/ui');
+
+module.exports = () => {
+  config.clearApiKey();
+  log.success('Logged out successfully. API Key removed from config.');
+};

package/commands/open.js

@@ -0,0 +1,32 @@
+const open = require('open');
+const config = require('../utils/config');
+const api = require('../utils/api');
+const { log } = require('../utils/ui');
+
+module.exports = async (projectName, options) => {
+  const baseUrl = config.getApiUrl();
+  const apiKey = options.key || config.getApiKey();
+  
+  if (!apiKey) {
+    log.error('Not authenticated. Please run "linage-cli login" first.');
+    return;
+  }
+
+  let url = `${baseUrl}`;
+
+  try {
+    const session = await api.get('/api/cli/whoami', { apiKey });
+    const orgSlug = session.organization.slug;
+
+    if (projectName) {
+      url = `${baseUrl}/${orgSlug}/projects/${projectName}`;
+    } else {
+      url = `${baseUrl}/${orgSlug}/dashboard`;
+    }
+
+    log.info(`Opening ${url}...`);
+    await open(url);
+  } catch (error) {
+    log.error(`Failed to open dashboard: ${error.message}`);
+  }
+};

package/commands/projects.js

@@ -0,0 +1,32 @@
+const { table } = require('table');
+const ora = require('ora');
+const api = require('../utils/api');
+const { log } = require('../utils/ui');
+
+module.exports = async (options) => {
+  const spinner = ora('Fetching projects...').start();
+  
+  try {
+    const apiOpts = {};
+    if (options.key) apiOpts.apiKey = options.key;
+
+    const data = await api.get('/api/cli/projects', apiOpts);
+    spinner.stop();
+
+    if (data.projects.length === 0) {
+      log.info('No projects found in this organization.');
+      return;
+    }
+
+    const outputData = [
+      ['Name', 'Code', 'Status', 'Latest Version'],
+      ...data.projects.map(p => [p.name, p.code, p.status, p.latestVersion])
+    ];
+
+    console.log(table(outputData));
+
+  } catch (error) {
+    spinner.fail('Failed to fetch projects.');
+    log.error(error.message);
+  }
+};

package/commands/stats.js

@@ -0,0 +1,33 @@
+const ora = require('ora');
+const api = require('../utils/api');
+const { log, printBox } = require('../utils/ui');
+const { table } = require('table');
+
+module.exports = async (options) => {
+  const spinner = ora('Calculating metrics...').start();
+  
+  try {
+    const apiOpts = {};
+    if (options.key) apiOpts.apiKey = options.key;
+
+    const data = await api.get('/api/cli/stats', apiOpts);
+    spinner.stop();
+
+    const { stats } = data;
+
+    printBox(`Organization Summary\n\nProjects: ${stats.projects}\nIngestions: ${stats.ingestions}\nTeam Members: ${stats.members}`, { borderColor: 'magenta' });
+
+    if (stats.ecosystems.length > 0) {
+        log.info('Ecosystem Distribution:');
+        const ecoTable = [
+            ['Ecosystem', 'Count'],
+            ...stats.ecosystems.map(e => [e.name || 'Unknown', e.count])
+        ];
+        console.log(table(ecoTable));
+    }
+
+  } catch (error) {
+    spinner.fail('Failed to fetch stats.');
+    log.error(error.message);
+  }
+};

package/commands/whoami.js

@@ -0,0 +1,21 @@
+const ora = require('ora');
+const api = require('../utils/api');
+const { log, printBox } = require('../utils/ui');
+
+module.exports = async (options) => {
+  const spinner = ora('Fetching session info...').start();
+  
+  try {
+    const apiOpts = {};
+    if (options.key) apiOpts.apiKey = options.key;
+
+    const data = await api.get('/api/cli/whoami', apiOpts);
+    
+    spinner.stop();
+    printBox(`Authenticated Session\n\nOrganization: ${data.organization.name}\nSlug: ${data.organization.slug}\nKey Name: ${data.keyName}`, { borderColor: 'green' });
+
+  } catch (error) {
+    spinner.fail('Failed to fetch info.');
+    log.error(error.message);
+  }
+};

package/index.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const { printHeader } = require('./utils/ui');
+
+// Import Commands
+const loginCmd = require('./commands/login');
+const ingestCmd = require('./commands/ingest');
+const projectsCmd = require('./commands/projects');
+const whoamiCmd = require('./commands/whoami');
+const logoutCmd = require('./commands/logout');
+const openCmd = require('./commands/open');
+const statsCmd = require('./commands/stats');
+
+// Initial Setup
+printHeader();
+
+program
+  .name('linage-cli')
+  .description("The Official CLI for Li'nage Cloud - Automate Dependency Discovery")
+  .version('1.0.0');
+
+program
+  .command('login')
+  .description('Interactive login to save your API Key')
+  .action(loginCmd);
+
+program
+  .command('ingest')
+  .description('Scan current directory and upload dependency graph')
+  .option('-k, --key <key>', 'Override API Key')
+  .option('-p, --project <name>', 'Override Project Code Name')
+  .action(ingestCmd);
+
+program
+  .command('projects')
+  .description('List all projects in your organization')
+  .option('-k, --key <key>', 'Override API Key')
+  .action(projectsCmd);
+
+program
+  .command('stats')
+  .description('Show organization health metrics')
+  .option('-k, --key <key>', 'Override API Key')
+  .action(statsCmd);
+
+program
+  .command('whoami')
+  .description('Show current authenticated session info')
+  .option('-k, --key <key>', 'Override API Key')
+  .action(whoamiCmd);
+
+program
+  .command('open [project]')
+  .description('Open your dashboard in the browser')
+  .option('-k, --key <key>', 'Override API Key')
+  .action(openCmd);
+
+program
+  .command('logout')
+  .description('Clear saved credentials')
+  .action(logoutCmd);
+
+// Normalize arguments to handle case-insensitivity
+const knownCommands = ['login', 'ingest', 'projects', 'whoami', 'logout', 'help', 'open', 'stats'];
+const knownFlags = ['--key', '--project', '--version', '--help'];
+
+const args = process.argv.map((arg, index) => {
+  if (index < 2) return arg; // Skip node and script path
+  
+  const lowerArg = arg.toLowerCase();
+  
+  // 1. Map -v to -V for version
+  if (arg === '-v') return '-V';
+  
+  // 2. Lowercase known commands
+  if (knownCommands.includes(lowerArg)) return lowerArg;
+  
+  // 3. Handle long flags (e.g., --KEY or --PROJECT)
+  if (arg.startsWith('--')) {
+    const parts = arg.split('=');
+    const flagName = parts[0].toLowerCase();
+    if (knownFlags.includes(flagName)) {
+      return parts.length > 1 ? `${flagName}=${parts.slice(1).join('=')}` : flagName;
+    }
+  }
+  
+  return arg;
+});
+
+program.parse(args);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "linage-cli",
+  "version": "1.0.0",
+  "description": "The Official CLI for Li'nage Cloud - Automate Dependency Discovery",
+  "main": "index.js",
+  "bin": "index.js",
+  "files": [
+    "index.js",
+    "commands/",
+    "utils/",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/linage-cloud/linage-cloud.git"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "linage",
+    "cli",
+    "dependencies",
+    "lineage",
+    "mapping"
+  ],
+  "author": "Li'nage",
+  "license": "ISC",
+  "dependencies": {
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "conf": "^10.2.0",
+    "figlet": "^1.9.4",
+    "gradient-string": "^3.0.0",
+    "inquirer": "^8.2.5",
+    "node-fetch": "^2.7.0",
+    "open": "^8.4.2",
+    "ora": "^5.4.1",
+    "table": "^6.8.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/utils/api.js

@@ -0,0 +1,65 @@
+const fetch = global.fetch || require('node-fetch');
+const config = require('./config');
+const { log } = require('./ui');
+
+const request = async (endpoint, method = 'GET', opts = {}) => {
+  const apiKey = opts.apiKey || config.getApiKey();
+  const baseUrl = config.getApiUrl();
+
+  if (!apiKey) {
+    throw new Error('Not authenticated. Please run "linage-cli login" first or provide --key.');
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${apiKey}`
+  };
+
+  const options = {
+    method,
+    headers,
+  };
+
+  if (opts.body) {
+    options.body = JSON.stringify(opts.body);
+  }
+
+  try {
+    const res = await fetch(`${baseUrl}${endpoint}`, options);
+    
+    // Handle 401 specifically
+    if (res.status === 401 || res.status === 403) {
+      throw new Error('Invalid or expired API Key. Please login again.');
+    }
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      throw new Error(data.error || data.message || `API Error: ${res.statusText}`);
+    }
+
+    return data;
+  } catch (error) {
+    throw error; // Re-throw to be handled by commands
+  }
+};
+
+module.exports = {
+  get: (endpoint, opts = {}) => request(endpoint, 'GET', opts),
+  post: (endpoint, body, opts = {}) => request(endpoint, 'POST', { ...opts, body }),
+  delete: (endpoint, opts = {}) => request(endpoint, 'DELETE', opts),
+  // Helper to validate key without throwing immediately
+  validateKey: async (key) => {
+    const baseUrl = config.getApiUrl();
+    try {
+      // We'll create a simple /api/whoami endpoint to validate
+      const res = await fetch(`${baseUrl}/api/cli/whoami`, {
+        headers: { 'Authorization': `Bearer ${key}` }
+      });
+      if (!res.ok) return false;
+      return await res.json();
+    } catch (e) {
+      return false;
+    }
+  }
+};

package/utils/config.js

@@ -0,0 +1,16 @@
+const Conf = require('conf');
+
+const config = new Conf({
+  projectName: 'linage-cli',
+  projectVersion: '1.0.0'
+});
+
+module.exports = {
+  getApiKey: () => config.get('apiKey'),
+  setApiKey: (key) => config.set('apiKey', key),
+  clearApiKey: () => config.delete('apiKey'),
+  
+  // Base URL handling (useful for dev vs prod switching if needed later)
+  getApiUrl: () => process.env.LINAGE_API_URL || config.get('apiUrl') || 'http://localhost:3000',
+  setApiUrl: (url) => config.set('apiUrl', url)
+};

package/utils/scanner.js

@@ -0,0 +1,26 @@
+const fs = require('fs');
+const path = require('path');
+
+const detectProject = () => {
+  const cwd = process.cwd();
+  
+  if (fs.existsSync(path.join(cwd, 'package.json'))) {
+    return { type: 'node', file: 'package.json' };
+  }
+  
+  if (fs.existsSync(path.join(cwd, 'requirements.txt'))) {
+    return { type: 'python', file: 'requirements.txt' };
+  }
+  
+  if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
+    return { type: 'rust', file: 'Cargo.toml' };
+  }
+  
+  if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+    return { type: 'go', file: 'go.mod' };
+  }
+
+  return null;
+};
+
+module.exports = { detectProject };

package/utils/ui.js

@@ -0,0 +1,35 @@
+const chalk = require('chalk');
+const figlet = require('figlet');
+const gradient = require('gradient-string');
+const boxen = require('boxen');
+
+const printHeader = () => {
+  console.log('');
+  console.log(gradient.pastel.multiline(figlet.textSync("LI'NAGE", { horizontalLayout: 'full' })));
+  console.log(chalk.dim("  Automated Dependency Discovery & Lineage Mapping by Li'nage"));
+  console.log('');
+};
+
+const log = {
+  info: (msg) => console.log(chalk.blue('ℹ'), msg),
+  success: (msg) => console.log(chalk.green('✔'), msg),
+  warning: (msg) => console.log(chalk.yellow('⚠'), msg),
+  error: (msg) => console.log(chalk.red('✖'), msg),
+  dim: (msg) => console.log(chalk.dim(msg)),
+};
+
+const printBox = (text, options = {}) => {
+  console.log(boxen(text, {
+    padding: 1,
+    margin: 1,
+    borderStyle: 'round',
+    borderColor: 'cyan',
+    ...options
+  }));
+};
+
+module.exports = {
+  printHeader,
+  log,
+  printBox
+};