dksetup 1.0.0

package/cli-tools/cli-template.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// cli-tools/cli-template.ts
+// Polished CLI tool template for DK-CLI
+
+import { Command } from 'commander';
+
+const program = new Command();
+
+program
+  .name('cli-template')
+  .description('A polished CLI tool template for DK-CLI')
+  .version('1.0.0')
+  .option('-v, --verbose', 'Enable verbose output')
+  .option('-c, --config <path>', 'Path to config file')
+  .argument('[input]', 'Input argument (optional)')
+  .action((input, options) => {
+    if (options.verbose) {
+      console.log('Verbose mode enabled');
+    }
+    if (options.config) {
+      console.log(`Using config: ${options.config}`);
+    }
+    if (input) {
+      console.log(`Input: ${input}`);
+    }
+    // TODO: Implement main logic here
+    console.log('CLI tool executed successfully.');
+  });
+
+program.parse(process.argv);

package/cli-tools/droi.ts

@@ -0,0 +1,27 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+export const DroiCliInstaller: Installer = {
+    name: 'Droi CLI',
+    description: 'Command line interface for Droi',
+    check: async () => {
+        try {
+            execSync('droi --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        console.log(chalk.cyan(`Installing ${chalk.bold('Droi CLI')}...`));
+
+        try {
+            console.log(chalk.gray('> npm install -g droi-cli'));
+            // execSync('npm install -g droi-cli', { stdio: 'inherit' });
+            console.log(chalk.green('✔ Droi CLI installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install Droi CLI.'));
+        }
+    }
+};

package/cli-tools/droid-agent.ts

@@ -0,0 +1,27 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+export const DroidAgentInstaller: Installer = {
+    name: 'Droid Agent CLI',
+    description: 'Command line interface for Droid Agent',
+    check: async () => {
+        try {
+            execSync('droid-agent --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        console.log(chalk.cyan(`Installing ${chalk.bold('Droid Agent CLI')}...`));
+
+        try {
+            console.log(chalk.gray('> npm install -g droid-agent-cli'));
+            // execSync('npm install -g droid-agent-cli', { stdio: 'inherit' });
+            console.log(chalk.green('✔ Droid Agent CLI installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install Droid Agent CLI.'));
+        }
+    }
+};

package/cli-tools/droid-factory.ts

@@ -0,0 +1,27 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+export const DroidFactoryInstaller: Installer = {
+    name: 'Droid Factory CLI',
+    description: 'Command line interface for Droid Factory',
+    check: async () => {
+        try {
+            execSync('droid-factory --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        console.log(chalk.cyan(`Installing ${chalk.bold('Droid Factory CLI')}...`));
+
+        try {
+            console.log(chalk.gray('> npm install -g droid-factory-cli'));
+            // execSync('npm install -g droid-factory-cli', { stdio: 'inherit' });
+            console.log(chalk.green('✔ Droid Factory CLI installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install Droid Factory CLI.'));
+        }
+    }
+};

package/cli-tools/gemini.ts

@@ -0,0 +1,28 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import * as os from 'os';
+import { execSync } from 'child_process';
+
+export const GeminiCliInstaller: Installer = {
+    name: 'Gemini CLI',
+    description: 'Command line interface for Google Gemini',
+    check: async () => {
+        try {
+            execSync('gemini --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        console.log(chalk.cyan(`Installing ${chalk.bold('Gemini CLI')}...`));
+
+        try {
+            console.log(chalk.gray('> npm install -g @google/gemini-cli'));
+            // execSync('npm install -g @google/gemini-cli', { stdio: 'inherit' });
+            console.log(chalk.green('✔ Gemini CLI installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install Gemini CLI.'));
+        }
+    }
+};

package/cli-tools/gh.ts

@@ -0,0 +1,35 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import * as os from 'os';
+
+export const GitHubCliInstaller: Installer = {
+    name: 'GitHub CLI (gh)',
+    description: 'GitHub on the command line',
+    check: async () => {
+        try {
+            execSync('gh --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        const platform = os.platform();
+        console.log(chalk.cyan(`Installing ${chalk.bold('GitHub CLI')}...`));
+
+        try {
+            if (platform === 'win32') {
+                console.log(chalk.gray('> winget install --id GitHub.cli'));
+                // execSync('winget install --id GitHub.cli', { stdio: 'inherit' });
+            } else if (platform === 'darwin') {
+                console.log(chalk.gray('> brew install gh'));
+            } else if (platform === 'linux') {
+                console.log(chalk.gray('> sudo apt-get install gh'));
+            }
+            console.log(chalk.green('✔ GitHub CLI installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install GitHub CLI.'));
+        }
+    }
+};

package/cli-tools/glm.ts

@@ -0,0 +1,27 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+export const GlmCliInstaller: Installer = {
+    name: 'GLM CLI',
+    description: 'Command line interface for ChatGLM',
+    check: async () => {
+        try {
+            execSync('glm --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        console.log(chalk.cyan(`Installing ${chalk.bold('GLM CLI')}...`));
+
+        try {
+            console.log(chalk.gray('> pip install chatglm-cli'));
+            // execSync('pip install chatglm-cli', { stdio: 'inherit' });
+            console.log(chalk.green('✔ GLM CLI installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install GLM CLI.'));
+        }
+    }
+};

package/cli-tools/kimi.ts

@@ -0,0 +1,27 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+export const KimiCliInstaller: Installer = {
+    name: 'Kimi CLI',
+    description: 'Command line interface for Moonshot Kimi',
+    check: async () => {
+        try {
+            execSync('kimi --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        console.log(chalk.cyan(`Installing ${chalk.bold('Kimi CLI')}...`));
+
+        try {
+            console.log(chalk.gray('> npm install -g moonshot-kimi-cli'));
+            // execSync('npm install -g moonshot-kimi-cli', { stdio: 'inherit' });
+            console.log(chalk.green('✔ Kimi CLI installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install Kimi CLI.'));
+        }
+    }
+};

package/cli-tools/opencode.ts

@@ -0,0 +1,27 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+export const OpencodeCliInstaller: Installer = {
+    name: 'OpenCode CLI',
+    description: 'Command line interface for OpenCode',
+    check: async () => {
+        try {
+            execSync('opencode --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        console.log(chalk.cyan(`Installing ${chalk.bold('OpenCode CLI')}...`));
+
+        try {
+            console.log(chalk.gray('> npm install -g opencode-cli'));
+            // execSync('npm install -g opencode-cli', { stdio: 'inherit' });
+            console.log(chalk.green('✔ OpenCode CLI installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install OpenCode CLI.'));
+        }
+    }
+};

package/editors/antigravity.ts

@@ -0,0 +1,24 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import * as os from 'os';
+
+export const AntigravityInstaller: Installer = {
+    name: 'Antigravity Workspace',
+    description: 'Agentic IDE by DeepMind',
+    check: async () => {
+        // Mock check
+        return false;
+    },
+    install: async () => {
+        const platform = os.platform();
+        console.log(chalk.cyan(`Installing ${chalk.bold('Antigravity')}...`));
+
+        try {
+            console.log(chalk.gray('> Antigravity installation process...'));
+            // Implementation depends on actual antigravity installer availability
+            console.log(chalk.green('✔ Antigravity installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install Antigravity.'));
+        }
+    }
+};

package/editors/opencode-desktop.ts

@@ -0,0 +1,23 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import * as os from 'os';
+
+export const OpencodeDesktopInstaller: Installer = {
+    name: 'OpenCode Desktop',
+    description: 'Open source desktop environment & editor',
+    check: async () => {
+        // Mock check
+        return false;
+    },
+    install: async () => {
+        console.log(chalk.cyan(`Installing ${chalk.bold('OpenCode Desktop')}...`));
+
+        try {
+            console.log(chalk.gray('> OpenCode Desktop installation process...'));
+            // specific install steps here depending on OS
+            console.log(chalk.green('✔ OpenCode Desktop installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install OpenCode Desktop.'));
+        }
+    }
+};

package/editors/vscode/extensions.ts

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+const EXTENSIONS = [
+    'esbenp.prettier-vscode',
+    'dbaeumer.vscode-eslint',
+    'eamodio.gitlens',
+    'pkief.material-icon-theme'
+];
+
+export async function installVsCodeExtensions() {
+    console.log(chalk.cyan(`Installing ${chalk.bold('VS Code Extensions')}...`));
+
+    for (const ext of EXTENSIONS) {
+        try {
+            console.log(chalk.gray(`> code --install-extension ${ext} --force`));
+            // execSync(`code --install-extension ${ext} --force`, { stdio: 'inherit' });
+            console.log(chalk.green(`✔ ${ext} installed.`));
+        } catch (error) {
+            console.log(chalk.red(`✖ Failed to install extension: ${ext}`));
+        }
+    }
+}

package/editors/vscode/installer.ts

@@ -0,0 +1,35 @@
+import { Installer } from '../../installers/installer.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import * as os from 'os';
+
+export const VsCodeInstaller: Installer = {
+    name: 'Visual Studio Code',
+    description: 'Code editor',
+    check: async () => {
+        try {
+            execSync('code --version', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    install: async () => {
+        const platform = os.platform();
+        console.log(chalk.cyan(`Installing ${chalk.bold('VS Code')}...`));
+
+        try {
+            if (platform === 'win32') {
+                console.log(chalk.gray('> winget install Microsoft.VisualStudioCode'));
+                // execSync('winget install Microsoft.VisualStudioCode', { stdio: 'inherit' });
+            } else if (platform === 'darwin') {
+                console.log(chalk.gray('> brew install --cask visual-studio-code'));
+            } else if (platform === 'linux') {
+                console.log(chalk.gray('> sudo snap install code --classic'));
+            }
+            console.log(chalk.green('✔ VS Code installed successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install VS Code.'));
+        }
+    }
+};

package/editors/zed.ts

@@ -0,0 +1,29 @@
+import { Installer } from '../installers/installer.js';
+import chalk from 'chalk';
+import * as os from 'os';
+
+export const ZedInstaller: Installer = {
+    name: 'Zed',
+    description: 'High-performance multiplayer code editor',
+    check: async () => {
+        // Mock check since Zed doesn't have a reliable CLI check on all platforms
+        return false;
+    },
+    install: async () => {
+        const platform = os.platform();
+        console.log(chalk.cyan(`Installing ${chalk.bold('Zed')}...`));
+
+        try {
+            if (platform === 'darwin') {
+                console.log(chalk.gray('> brew install --cask zed'));
+            } else if (platform === 'linux') {
+                console.log(chalk.gray('> curl -f https://zed.dev/install.sh | sh'));
+            } else {
+                console.log(chalk.yellow('⚠ Zed has limited support on Windows. Please check zed.dev for updates.'));
+            }
+            console.log(chalk.green('✔ Zed installed (or attempted) successfully!'));
+        } catch (error) {
+            console.log(chalk.red('✖ Failed to install Zed.'));
+        }
+    }
+};

package/index.ts

@@ -0,0 +1,223 @@
+import { prompt } from 'enquirer';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import * as os from 'os';
+
+// Import Interfaces
+import { Installer } from './installers/installer.js';
+
+// Core Installers
+import { GitInstaller } from './installers/git.js';
+import { NodeInstaller } from './languages/nodejs.js'; // Note it was moved
+import { NpmInstaller } from './installers/npm.js';
+import { BlenderInstaller } from './installers/blender.js';
+import { PowerToysInstaller } from './installers/powertoys.js';
+
+// Languages
+import { PythonInstaller } from './languages/python.js';
+import { TypeScriptInstaller } from './languages/typescript.js';
+import { CppInstaller } from './languages/cpp.js';
+
+// Editors
+import { VsCodeInstaller } from './editors/vscode/installer.js';
+import { installVsCodeExtensions } from './editors/vscode/extensions.js';
+import { ZedInstaller } from './editors/zed.js';
+import { AntigravityInstaller } from './editors/antigravity.js';
+import { OpencodeDesktopInstaller } from './editors/opencode-desktop.js';
+
+// CLI Tools
+import { GitHubCliInstaller } from './cli-tools/gh.js';
+import { GeminiCliInstaller } from './cli-tools/gemini.js';
+import { KimiCliInstaller } from './cli-tools/kimi.js';
+import { GlmCliInstaller } from './cli-tools/glm.js';
+import { OpencodeCliInstaller } from './cli-tools/opencode.js';
+import { DroiCliInstaller } from './cli-tools/droi.js';
+import { DroidFactoryInstaller } from './cli-tools/droid-factory.js';
+import { DroidAgentInstaller } from './cli-tools/droid-agent.js';
+import { ClaudeCodeInstaller } from './cli-tools/claude.js';
+
+const program = new Command();
+
+program
+    .name('dk-cli')
+    .description('Full Environment Setup (Cross-Platform CLI Dashboard)')
+    .version('1.0.0');
+
+// Grouping and Configuration
+const categories = {
+    'Core Tools': [GitInstaller, NodeInstaller, NpmInstaller, BlenderInstaller, PowerToysInstaller],
+    'Languages': [PythonInstaller, TypeScriptInstaller, CppInstaller],
+    'Editors': [VsCodeInstaller, ZedInstaller, AntigravityInstaller, OpencodeDesktopInstaller],
+    'CLI AI Agents & Tools': [
+        GitHubCliInstaller, GeminiCliInstaller, KimiCliInstaller, GlmCliInstaller,
+        OpencodeCliInstaller, DroiCliInstaller, DroidFactoryInstaller,
+        DroidAgentInstaller, ClaudeCodeInstaller
+    ]
+};
+
+async function runDashboard() {
+    const bannerText = [
+        "██████╗ ██╗  ██╗    ██████╗██╗     ██╗",
+        "██╔══██╗██║ ██╔╝   ██╔════╝██║     ██║",
+        "██║  ██║█████╔╝    ██║     ██║     ██║",
+        "██║  ██║██╔═██╗    ██║     ██║     ██║",
+        "██████╔╝██║  ██╗██╗╚██████╗███████╗██║",
+        "╚═════╝ ╚═╝  ╚═╝╚═╝ ╚═════╝╚══════╝╚═╝"
+    ];
+
+    const { getAnimationFrames } = await import('./installers/animator.js');
+    const introFrames = getAnimationFrames('ASCII Animations/ring aniamtion.html');
+    const gradient = (await import('gradient-string')).default;
+
+    if (introFrames.length > 0) {
+        console.clear();
+        for (let i = 0; i < 40; i++) {
+            const frameIdx = i % introFrames.length;
+            const frameLines = introFrames[frameIdx].split('\n');
+            const height = Math.max(bannerText.length, frameLines.length);
+            const combinedLines = [];
+            for (let line = 0; line < height; line++) {
+                const bLine = bannerText[line] || '';
+                const fLine = frameLines[line] || '';
+                combinedLines.push(bLine.padEnd(42, ' ') + fLine);
+            }
+            process.stdout.write('\x1b[0;0H');
+            console.log(gradient.rainbow(combinedLines.join('\n')));
+            await new Promise(r => setTimeout(r, 60));
+        }
+    } else {
+        const chalkAnimation = (await import('chalk-animation')).default;
+        console.clear();
+        const banner = chalkAnimation.rainbow(bannerText.join('\n'));
+        await new Promise(r => setTimeout(r, 2000));
+        banner.stop();
+    }
+
+    console.log(chalk.gray('The ultimate cross-platform dev environment bootstrap.\n'));
+
+    // OS Overview
+    const osType = os.platform();
+    const osRelease = os.release();
+    let osName = 'Unknown';
+    if (osType === 'win32') osName = 'Windows';
+    else if (osType === 'darwin') osName = 'macOS';
+    else if (osType === 'linux') osName = 'Linux';
+    console.log(`${chalk.bold('System:')} ${chalk.green(osName)} ${chalk.gray(`(${osRelease})`)}\n`);
+
+    try {
+        // Step 1: Category Selection
+        const { selectedCategories } = await prompt<{ selectedCategories: string[] }>({
+            type: 'multiselect',
+            name: 'selectedCategories',
+            message: 'Which categories do you want to configure? (Space to toggle, Enter to confirm)',
+            choices: Object.keys(categories),
+            indicator(state: any, choice: any) {
+                return choice.enabled ? chalk.cyan('●') : chalk.gray('○');
+            }
+        } as any);
+
+        if (!selectedCategories || selectedCategories.length === 0) {
+            console.log(chalk.yellow('\nNo categories selected. Exiting...'));
+            process.exit(0);
+        }
+
+        // Step 2: Tool Selection per Category
+        const finalInstallers: Installer[] = [];
+        let installVsCodeExts = false;
+
+        for (const cat of selectedCategories) {
+            console.log(); // Spacing
+            const tools = categories[cat as keyof typeof categories];
+
+            const { selectedTools } = await prompt<{ selectedTools: string[] }>({
+                type: 'multiselect',
+                name: 'selectedTools',
+                message: `Select tools from ${chalk.bold.cyan(cat)}:`,
+                choices: tools.map(t => ({ name: t.name, value: t.name })),
+                indicator(state: any, choice: any) {
+                    return choice.enabled ? chalk.cyan('●') : chalk.gray('○');
+                }
+            } as any);
+
+            // Special case for VS Code extensions
+            if (selectedTools.includes(VsCodeInstaller.name)) {
+                const { exts } = await prompt<{ exts: boolean }>({
+                    type: 'confirm',
+                    name: 'exts',
+                    message: `Would you like to install the curated ${chalk.bold('VS Code Extensions')} as well?`,
+                    initial: true
+                } as any);
+                installVsCodeExts = exts;
+            }
+
+            const matchedInstallers = tools.filter(t => selectedTools.includes(t.name));
+            finalInstallers.push(...matchedInstallers);
+        }
+
+        if (finalInstallers.length === 0) {
+            console.log(chalk.yellow('\nNo tools selected. Exiting...'));
+            process.exit(0);
+        }
+
+        // Step 3: Execution Engine
+        const chalkAnimation = (await import('chalk-animation')).default;
+        const transition = chalkAnimation.glitch('\n[ PREPARING SELECTED MODULES ]\n');
+        await new Promise(r => setTimeout(r, 1500));
+        transition.stop();
+
+        console.log(chalk.bold.blue('🚀 Commencing Setup...\n'));
+
+        const { getAnimationFrames } = await import('./installers/animator.js');
+        const frames = getAnimationFrames('ASCII Animations/ring aniamtion.html');
+        // Fallback to standard line spinner if frames fail to load
+        const fallbackSpinner = ['-', '\\', '|', '/'];
+        const spinnerFrames = frames.length > 0 ? frames : fallbackSpinner;
+
+        const ora = (await import('ora')).default;
+
+        for (const installer of finalInstallers) {
+            console.log(chalk.bold(`➜ ${installer.name}`) + chalk.gray(` - ${installer.description}`));
+
+            const isInstalled = await installer.check();
+            if (isInstalled) {
+                console.log(chalk.yellow(`  ℹ Already installed or present. Skipping.\n`));
+                continue;
+            }
+
+            const spinner = ora({
+                text: `Installing ${installer.name}...`,
+                spinner: {
+                    interval: frames.length > 0 ? 30 : 80,
+                    frames: spinnerFrames
+                }
+            }).start();
+
+            try {
+                await installer.install();
+                spinner.succeed(chalk.green(`Installed ${installer.name} successfully!`));
+            } catch (error) {
+                spinner.fail(chalk.red(`Failed to install ${installer.name}.`));
+            }
+            console.log(); // Spacing
+        }
+
+        if (installVsCodeExts) {
+            console.log(chalk.bold(`➜ VS Code Extensions`));
+            await installVsCodeExtensions();
+            console.log();
+        }
+
+        console.log(chalk.bold.green('🎉 Setup Complete! Enjoy your new environment.'));
+
+    } catch (err) {
+        if ((err as Error).message === '') {
+            // User pressed Ctrl+C
+            console.log(chalk.gray('\nDashboard exited safely.'));
+        } else {
+            console.error(chalk.red('An error occurred during setup:'), err);
+        }
+    }
+}
+
+program.action(runDashboard);
+program.parse(process.argv);