@a5gard/asgard 0.0.1

package/src/commands/delete-version.js

@@ -0,0 +1,74 @@
+import { Command, Flags } from '@oclif/core';
+import { execSync } from 'child_process';
+import { ux } from '@oclif/core';
+import ora from 'ora';
+import { boxStart, boxDivider, boxEnd, boxLine } from '../utils/box.js';
+
+export default class DeleteVersion extends Command {
+  static description = 'Delete git tags (local and remote)';
+  
+  static flags = {
+    tag: Flags.string({ char: 't', description: 'Tag name' })
+  };
+
+  async run() {
+    const cwd = process.cwd();
+    boxStart('Delete Version');
+    
+    const { flags } = await this.parse(DeleteVersion);
+    let tagName = flags.tag;
+
+    const spinner = ora('Loading tags...').start();
+    
+    let tags = [];
+    try {
+      const tagsRaw = execSync('git tag', { cwd, encoding: 'utf8' }).trim();
+      tags = tagsRaw ? tagsRaw.split('\n').reverse() : [];
+    } catch (e) {
+      tags = [];
+    }
+    
+    spinner.stop();
+
+    if (tags.length === 0) {
+      boxLine('No tags found', 'warning');
+      boxDivider();
+      boxEnd(false, 'No tags available');
+      return;
+    }
+
+    if (!tagName) {
+      boxLine('Please select a tag to delete:');
+      boxDivider();
+      
+      tagName = await ux.select({
+        message: 'Select tag to delete',
+        options: tags.map(t => ({ label: t, value: t }))
+      });
+      boxDivider();
+    }
+
+    const deleteSpinner = ora(`Deleting tag '${tagName}'...`).start();
+    
+    try {
+      execSync(`git tag -d ${tagName}`, { cwd, stdio: 'pipe' });
+      
+      try {
+        execSync(`git push origin --delete ${tagName}`, { cwd, stdio: 'pipe' });
+        boxLine(`Tag '${tagName}' deleted locally and from origin`, 'success');
+      } catch (remoteError) {
+        boxLine(`Tag '${tagName}' deleted locally (failed to delete from remote)`, 'warning');
+      }
+
+      deleteSpinner.stop();
+      boxDivider();
+      boxEnd(true, 'Complete');
+    } catch (error) {
+      deleteSpinner.stop();
+      const msg = error.stderr ? error.stderr.toString() : error.message;
+      boxLine(msg, 'error');
+      boxDivider();
+      boxEnd(false, 'Delete failed');
+    }
+  }
+}

package/src/commands/download-file.js

@@ -0,0 +1,101 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { downloadFile } from '../git/helpers.js';
+import { boxStart, boxDivider, boxEnd, boxLine } from '../utils/box.js';
+import { syncRepo } from '../git/sync-repo.js';
+
+export default class DownloadFile extends Command {
+  static description = 'Download a specific file from a GitHub repository';
+
+  static args = [
+    { name: 'repo', description: 'Repository owner/repo', required: false },
+    { name: 'file', description: 'File path to download', required: false },
+  ];
+
+  static flags = {
+    url: Flags.string({ char: 'u', description: 'Full GitHub URL to file' }),
+    owner: Flags.string({ char: 'o', description: 'Repository owner' }),
+    repo: Flags.string({ char: 'r', description: 'Repository name' }),
+    path: Flags.string({ char: 'p', description: 'File path in repository' }),
+    branch: Flags.string({ char: 'b', description: 'Branch name', default: 'main' }),
+  };
+
+  async run() {
+    boxStart('Download File');
+    
+    await syncRepo();
+    const { args, flags } = await this.parse(DownloadFile);
+    
+    let owner, repo, filePath, branch;
+    
+    if (flags.url) {
+      const urlPattern = /github\.com\/([^\/]+)\/([^\/]+)\/blob\/([^\/]+)\/(.+)/;
+      const match = flags.url.match(urlPattern);
+      
+      if (!match) {
+        boxLine('Invalid GitHub URL format', 'error');
+        boxDivider();
+        boxEnd(false, 'Invalid URL');
+        return;
+      }
+      
+      [, owner, repo, branch, filePath] = match;
+      await downloadFile(owner, repo, filePath, branch);
+      boxDivider();
+      boxEnd(true, 'Complete');
+      return;
+    }
+    
+    if (flags.owner && flags.repo && flags.path) {
+      owner = flags.owner;
+      repo = flags.repo;
+      filePath = flags.path;
+      branch = flags.branch;
+      await downloadFile(owner, repo, filePath, branch);
+      boxDivider();
+      boxEnd(true, 'Complete');
+      return;
+    }
+    
+    let repoArg = args.repo;
+    let fileArg = args.file;
+    
+    if (!repoArg || !fileArg) {
+      boxLine('Download a specific file from a GitHub repository.');
+      boxDivider();
+      
+      const response = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'repo',
+          message: 'Repository owner/repo:',
+          prefix: '',
+          suffix: '',
+          when: !repoArg,
+          validate: input => input.trim().length > 0 || 'Repository cannot be empty',
+        },
+        {
+          type: 'input',
+          name: 'file',
+          message: 'File path:',
+          prefix: '',
+          suffix: '',
+          when: !fileArg,
+          validate: input => input.trim().length > 0 || 'File path cannot be empty',
+        },
+      ]);
+      
+      repoArg = repoArg || response.repo;
+      fileArg = fileArg || response.file;
+      boxDivider();
+    }
+    
+    const parts = repoArg.replace('https://github.com/', '').replace('.git', '').split('/');
+    owner = parts[0];
+    repo = parts[1] || parts[0];
+    
+    await downloadFile(owner, repo, fileArg, flags.branch);
+    boxDivider();
+    boxEnd(true, 'Complete');
+  }
+}

package/src/commands/download-folder.js

@@ -0,0 +1,123 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { downloadFolder, downloadFolderRaw } from '../git/helpers.js';
+import { boxStart, boxDivider, boxEnd, boxLine } from '../utils/box.js';
+import { syncRepo } from '../git/sync-repo.js';
+
+export default class DownloadFolder extends Command {
+  static description = 'Download a specific folder from a GitHub repository';
+
+  static args = [
+    { name: 'repo', description: 'Repository URL or owner/repo', required: false },
+    { name: 'folder', description: 'Folder path to download', required: false },
+  ];
+
+  static flags = {
+    url: Flags.string({ char: 'u', description: 'Full GitHub URL to folder' }),
+    owner: Flags.string({ char: 'o', description: 'Repository owner' }),
+    repo: Flags.string({ char: 'r', description: 'Repository name' }),
+    path: Flags.string({ char: 'p', description: 'Folder path in repository' }),
+    branch: Flags.string({ char: 'b', description: 'Branch name', default: 'main' }),
+    raw: Flags.boolean({ description: 'Use raw HTTP method instead of sparse checkout', default: false }),
+  };
+
+  async run() {
+    boxStart('Download Folder');
+    
+    await syncRepo();
+    const { args, flags } = await this.parse(DownloadFolder);
+    
+    let owner, repo, folderPath, branch;
+    
+    if (flags.url) {
+      const urlPattern = /github\.com\/([^\/]+)\/([^\/]+)\/(?:tree|blob)\/([^\/]+)\/(.+)/;
+      const match = flags.url.match(urlPattern);
+      
+      if (!match) {
+        boxLine('Invalid GitHub URL format', 'error');
+        boxDivider();
+        boxEnd(false, 'Invalid URL');
+        return;
+      }
+      
+      [, owner, repo, branch, folderPath] = match;
+      
+      if (flags.raw) {
+        await downloadFolderRaw(owner, repo, folderPath, branch);
+      } else {
+        const repoUrl = `https://github.com/${owner}/${repo}.git`;
+        await downloadFolder(repoUrl, folderPath, branch);
+      }
+      boxDivider();
+      boxEnd(true, 'Complete');
+      return;
+    }
+    
+    if (flags.owner && flags.repo && flags.path) {
+      owner = flags.owner;
+      repo = flags.repo;
+      folderPath = flags.path;
+      branch = flags.branch;
+      
+      if (flags.raw) {
+        await downloadFolderRaw(owner, repo, folderPath, branch);
+      } else {
+        const repoUrl = `https://github.com/${owner}/${repo}.git`;
+        await downloadFolder(repoUrl, folderPath, branch);
+      }
+      boxDivider();
+      boxEnd(true, 'Complete');
+      return;
+    }
+    
+    let repoArg = args.repo;
+    let folderArg = args.folder;
+    
+    if (!repoArg || !folderArg) {
+      boxLine('Download a specific folder from a GitHub repository.');
+      boxLine('Default method: Sparse checkout (works with any Git provider)');
+      boxLine('Raw method (--raw): Direct HTTP download (GitHub only)');
+      boxDivider();
+      
+      const response = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'repo',
+          message: 'Repository URL or owner/repo:',
+          prefix: '',
+          suffix: '',
+          when: !repoArg,
+          validate: input => input.trim().length > 0 || 'Repository cannot be empty',
+        },
+        {
+          type: 'input',
+          name: 'folder',
+          message: 'Folder path:',
+          prefix: '',
+          suffix: '',
+          when: !folderArg,
+          validate: input => input.trim().length > 0 || 'Folder path cannot be empty',
+        },
+      ]);
+      
+      repoArg = repoArg || response.repo;
+      folderArg = folderArg || response.folder;
+      boxDivider();
+    }
+    
+    if (flags.raw) {
+      const parts = repoArg.replace('https://github.com/', '').replace('.git', '').split('/');
+      owner = parts[0];
+      repo = parts[1];
+      await downloadFolderRaw(owner, repo, folderArg, flags.branch);
+    } else {
+      let repoUrl = repoArg;
+      if (!repoUrl.startsWith('http')) {
+        repoUrl = `https://github.com/${repoArg}.git`;
+      }
+      await downloadFolder(repoUrl, folderArg, flags.branch);
+    }
+    boxDivider();
+    boxEnd(true, 'Complete');
+  }
+}

package/src/commands/download-source.js

@@ -0,0 +1,51 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { cloneRepo } from '../git/helpers.js';
+import { boxStart, boxDivider, boxEnd, boxLine } from '../utils/box.js';
+
+export default class Download extends Command {
+  static description = 'Clone a GitHub repository';
+
+  static args = [{ name: 'repo', description: 'URL or owner/repo' }];
+
+  static flags = {
+    dir: Flags.string({ char: 'd', description: 'Target directory' }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(Download);
+    boxStart('Clone Repository');
+    
+    let repoInput = args.repo;
+
+    // 1. Prompt if no arg provided
+    if (!repoInput) {
+      const answers = await inquirer.prompt([{
+        type: 'input',
+        name: 'repo',
+        message: 'Repository (URL or owner/repo):',
+        prefix: '', suffix: '',
+        validate: i => i.trim().length > 0
+      }]);
+      repoInput = answers.repo;
+      boxDivider();
+    }
+
+    // 2. Format the URL (Assume GitHub if it's just owner/repo)
+    const repoUrl = repoInput.startsWith('http') 
+      ? repoInput 
+      : `https://github.com/${repoInput}.git`;
+
+    // 3. Execution
+    try {
+      await cloneRepo(repoUrl, flags.dir || '');
+      boxLine(`Cloned to ${flags.dir || 'current directory'}`, 'success');
+      boxDivider();
+      boxEnd(true, 'Complete');
+    } catch (error) {
+      boxLine(error.message, 'error');
+      boxDivider();
+      boxEnd(false, 'Clone failed');
+    }
+  }
+}

package/src/commands/gh-setup.js

@@ -0,0 +1,77 @@
+import { Command } from '@oclif/core';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { boxStart, boxEnd, boxLine, boxDivider, boxList, boxPrompt, boxWaitForEnter} from '../utils/box.js';
+
+export default class GhSetup extends Command {
+  static description = 'Step-by-step guide to install and authenticate GitHub CLI';
+
+  async run() {
+    try {
+      boxStart('Asgard: GitHub CLI Setup');
+
+      boxLine('1. Download & Install the official GitHub CLI');
+      boxLine('   Direct Link: https://cli.github.com/');
+      boxLine('   (Or run: winget install --id GitHub.cli)');
+      
+      boxLine('Press [ENTER] once you have finished the installation...', 'warning');
+
+      await boxWaitForEnter();
+
+      this.refreshWindowsPath();
+
+
+      boxDivider();
+      boxLine('3. Authenticating with GitHub...', 'info');
+      boxLine('   The browser will open to link your account.', 'info');
+      boxLine('   Choose SSH when prompted for preferred protocol.', 'warning');
+      boxDivider();
+
+      try {
+        execSync(`gh auth login`, { stdio: 'inherit' });
+        
+        boxDivider();
+        boxLine('✓ GitHub CLI is now ready to use!', 'success');
+        boxEnd(true, 'Setup Complete');
+      } catch (error) {
+        boxLine('Authentication was cancelled or failed.', 'error');
+        boxLine(`Error: ${error.message}`, 'error');
+        if (error.stderr) boxLine(`Details: ${error.stderr.toString()}`, 'error');
+        boxLine('Note: If you just installed it, you might need to try opening a new terminal.', 'warning');
+        boxEnd(false, 'Setup Failed');
+      }
+    } catch (error) {
+      console.error('Fatal error:');
+      console.error(error.message);
+      console.error(error.stack);
+      process.exit(1);
+    }
+  }
+
+  refreshWindowsPath() {
+    if (process.platform === 'win32') {
+      try {
+        const updatedPath = execSync(
+          `powershell -NoProfile -Command "[Environment]::GetEnvironmentVariable('Path', 'Machine') + ';' + [Environment]::GetEnvironmentVariable('Path', 'User')"`
+        ).toString().trim();
+        
+        if (updatedPath) {
+          process.env.PATH = updatedPath;
+        }
+      } catch (e) {
+      }
+    }
+  }
+
+  async waitForEnter() {
+    return new Promise((resolve) => {
+      process.stdin.resume();
+      process.stdin.once('data', () => {
+        process.stdin.pause();
+        resolve();
+      });
+    });
+  }
+}

package/src/commands/load-project.js

@@ -0,0 +1,63 @@
+import { Command } from '@oclif/core';
+import { execSync } from 'child_process';
+import { ux } from '@oclif/core';
+import ora from 'ora';
+import { boxStart, boxDivider, boxEnd, boxLine } from '../utils/box.js';
+
+export default class LoadProject extends Command {
+  static description = 'Restore stashed work';
+
+  async run() {
+    const cwd = process.cwd();
+    boxStart('Load Project');
+    
+    const spinner = ora('Loading stash list...').start();
+
+    try {
+      let stashRaw = '';
+      try {
+        stashRaw = execSync('git stash list', { cwd, encoding: 'utf8' }).trim();
+      } catch (e) {
+        // Git returns error if not a repo
+      }
+      spinner.stop();
+
+      if (!stashRaw) {
+        boxLine('No stashes found', 'warning');
+        boxDivider();
+        boxEnd(false, 'No stashes available');
+        return;
+      }
+
+      const stashes = stashRaw.split('\n').map((line, index) => ({
+        label: line,
+        value: index
+      }));
+
+      boxLine('Please select a stash to restore:');
+      boxDivider();
+
+      const stashIndex = await ux.select({
+        message: 'Select stash to restore',
+        options: stashes
+      });
+
+      boxDivider();
+
+      const restoreSpinner = ora('Restoring stash...').start();
+      // Using pop to restore and remove from list
+      execSync(`git stash pop stash@{${stashIndex}}`, { cwd, stdio: 'pipe' });
+      
+      restoreSpinner.stop();
+      boxLine('Stash restored', 'success');
+      boxDivider();
+      boxEnd(true, 'Complete');
+    } catch (error) {
+      spinner.stop();
+      const msg = error.stderr ? error.stderr.toString() : error.message;
+      boxLine(msg, 'error');
+      boxDivider();
+      boxEnd(false, 'Load failed');
+    }
+  }
+}

package/src/commands/menu.js

@@ -0,0 +1,46 @@
+import { Command } from '@oclif/core';
+import { ux } from '@oclif/core';
+import { boxStart, boxDivider, boxEnd, boxLine } from '../utils/box.js';
+
+export default class Index extends Command {
+  static description = 'Asgard CLI - Interactive menu';
+
+  async run() {
+    boxStart('Asgard CLI');
+    boxLine('Select a command to run:');
+    boxDivider();
+
+    const command = await ux.select({
+      message: 'What would you like to do?',
+      options: [
+        { label: 'Install BALDR Icons - Icons library for react applications', value: 'baldr' },
+        { label: 'GH Setup - githubs CLI is required for some functionality', value: 'create-project' },
+        { label: 'Create Project - Create a new project with GitHub repository', value: 'create-project' },
+        { label: 'Publish Project - Create GitHub repository for existing project', value: 'publish-project' },
+        { label: 'Download - Clone a GitHub repository', value: 'download' },
+        { label: 'Download File - Download a specific file from a repository', value: 'download-file' },
+        { label: 'Download Folder - Download a specific folder from a repository', value: 'download-folder' },
+        { label: 'Save - Add, commit, and push changes', value: 'save' },
+        { label: 'Load Project - Restore stashed work', value: 'load-project' },
+        { label: 'Create Timeline - Create a new branch', value: 'create-timeline' },
+        { label: 'Delete Timeline - Delete a branch', value: 'delete-timeline' },
+        { label: 'Replace Timeline - Merge branch into main and delete source', value: 'replace-timeline' },
+        { label: 'Delete Version - Delete git tags', value: 'delete-version' },
+        { label: 'Set Source - Replace remote URL', value: 'set-source' },
+        { label: 'Delete Source - Remove a remote', value: 'delete-source' },
+        { label: 'Exit', value: 'exit' }
+      ]
+    });
+
+    boxDivider();
+
+    if (command === 'exit') {
+      boxEnd(true, 'Goodbye!');
+      return;
+    }
+
+    boxEnd(true, `Running ${command}...`);
+    
+    await this.config.runCommand(command);
+  }
+}

package/src/commands/midgardr.js

@@ -0,0 +1,25 @@
+// src/commands/midgardr.js
+import { Command } from '@oclif/core'
+import { execSync } from 'child_process';
+
+export default class MidgardrCommand extends Command {
+  static description = 'UI components installation and management'
+  static strict = false
+  
+  async run(){
+    const { argv } = await this.parse(MidgardrCommand)
+    const cwd = process.cwd();
+    
+    // SILENTLY check if midgardr is installed
+    try {
+      execSync('midgardr --version', { cwd, stdio: 'inherit' });
+    } catch {
+      // SILENTLY install if not found
+      execSync('npm install -g @a5gard/midgardr-cli', { cwd, stdio: 'inherit' });
+    }
+    
+    // COMPLETE PASSTHROUGH - run midgardr with all arguments
+    // This shows midgardr's output exactly as if user ran it directly
+    execSync(`midgardr ${argv}`, {cwd, stdio: 'inherit'  })
+  }
+}