workon 2.1.2 → 3.0.0

package/cli/index.js

@@ -1,184 +0,0 @@
-const {container} = require('./base');
-
-const File = require('phylo');
-
-const Config = require('../lib/config');
-const {EnvironmentRecognizer} = require('../lib/environment');
-
-const config = require('./config');
-const interactive = require('./interactive');
-const open = require('./open');
-const manage = require('./manage');
-
-class workon extends container {
-    constructor (log) {
-        super();
-        let me = this;
-        me.log = log || require('loog')({
-            prefixStyle: 'ascii'
-        });
-    }
-
-    run () {
-        let me = this;
-        me.initialize();
-        me.prepareCompletion();
-        return super.run();
-    }
-
-    initialize () {
-        let me = this;
-        me.log.debug('Log system initialized');
-        me.rootDir = File.from(__dirname).up('package.json');
-        me.log.debug(`Using ${me.rootDir} as root directory`);
-        me.config = new Config();
-        me.log.debug('Configuration system initialized');
-        me.log.debug("Loading package config, 'pkg' namespace");
-        me.config.set('pkg', me.rootDir.join('package.json').load());
-        EnvironmentRecognizer.configure(me.config, me.log);
-    }
-
-    prepareCompletion () {
-        let me = this;
-        let tree = {
-            config: [
-                'list', 'set', 'reset'
-            ]
-        };
-        let projects = me.config.get('projects');
-        if (projects) {
-            Object.keys(projects).forEach((id) => {
-                tree[id] = null;
-            });
-        }
-        me.completion = require('omelette')('workon').tree(tree);
-        me.completion.init();
-    }
-
-    execute (params, args) {
-        let me = this;
-
-        if (params.debug) {
-            me.log.setLogLevel('debug');
-        }
-
-        if (params.completion) {
-            me.log.debug('Setting up command-line completion');
-            me.completion.setupShellInitFile();
-            return true;
-        } else if (params.init) {
-            me.log.debug('Generating shell integration function');
-            me.outputShellInit();
-            return true;
-        } else {
-            let prom = Promise.resolve();
-            if (!me.environment) {
-                prom = EnvironmentRecognizer.recognize(File.cwd())
-                    .then((environment) => {
-                        me.environment = environment;
-                    });
-            }
-            return prom.then(() => super.execute(params, args).catch((err) => me.maybeOpen(err, args)));
-        }
-    }
-
-    outputShellInit () {
-        let me = this;
-        
-        // Get list of available commands from switchit
-        let cmdNames = me.constructor.getAspects().commands.filter((c) => !!c).map((c) => c.name);
-        
-        // Get list of available switches from switchit
-        let switches = me.constructor.getAspects().switches || [];
-        let switchFlags = [];
-        switches.forEach(sw => {
-            switchFlags.push('--' + sw.name);
-            if (sw.char) {
-                switchFlags.push('-' + sw.char);
-            }
-        });
-        
-        // Add built-in switchit flags (help and version are automatically added by switchit)
-        let builtinFlags = ['--help', '-h', '--version', '-v', 'help'];
-        
-        // Combine all non-shell commands and flags, removing duplicates
-        let nonShellCommands = [...new Set(cmdNames.concat(switchFlags).concat(builtinFlags))];
-        let casePattern = nonShellCommands.join('|');
-        
-        // Generate shell function that wraps workon calls
-        let shellFunction = `
-# workon shell integration
-workon() {
-    # Commands and flags that should NOT use shell mode
-    case "$1" in
-        ${casePattern})
-            command workon "$@"
-            return $?
-            ;;
-    esac
-    
-    # If no arguments provided, run interactive mode directly
-    if [[ $# -eq 0 ]]; then
-        command workon "$@"
-        return $?
-    fi
-    
-    # Default behavior: use shell mode for project opening
-    local output
-    output=$(command workon --shell "$@" 2>&1)
-    local exit_code=$?
-    
-    if [[ $exit_code -eq 0 && -n "$output" ]]; then
-        # Execute shell commands if workon succeeded and output exists
-        eval "$output"
-    else
-        # Show any error output
-        [[ -n "$output" ]] && echo "$output" >&2
-        return $exit_code
-    fi
-}`;
-        console.log(shellFunction);
-    }
-
-    maybeOpen (err, args) {
-        let me = this;
-        let cmdNames = me.constructor.getAspects().commands.filter((c) => !!c).map((c) => c.name);
-        let firstCmd = args._args.filter((a) => !/^-/.test(a))[0];
-        if (!~cmdNames.indexOf(firstCmd)) {
-            // ex. "workon projectName"
-            let openCmd = me.commands.lookup('open').create(me);
-            // Copy shell parameter to the open command
-            if (me.params.shell) {
-                openCmd.params = openCmd.params || {};
-                openCmd.params.shell = true;
-            }
-            return openCmd.run(args._args);
-        } else {
-            // ex. "workon config asdf"
-            throw err;
-        }
-    }
-}
-
-workon.define({
-    help: {
-        '': 'Work on something great!',
-        debug: 'Provide debug logging output',
-        completion: 'Configure and generate shell tab completion',
-        shell: 'Output shell commands instead of spawning processes',
-        init: 'Generate shell integration function for seamless directory switching'
-    },
-    switches: '[d#debug:boolean=false] [completion:boolean=false] [shell:boolean=false] [init:boolean=false]',
-    commands: {
-        '': 'open',
-        interactive: {
-            type: interactive,
-            private: true
-        },
-        open,
-        config,
-        manage
-    }
-});
-
-module.exports = workon;

package/cli/interactive.js

@@ -1,290 +0,0 @@
-const { command } = require('./base');
-const inquirer = require('inquirer');
-const File = require('phylo');
-const Prompt = require('inquirer/lib/prompts/input');
-const deepAssign = require('deep-assign');
-
-class interactive extends command {
-    execute (params) {
-        let me = this;
-        me.log.debug();
-        me.showLogo();
-        me.log.log();
-        let name;
-        let fromUser = false;
-        if (!params.identifier || params.identifier === 'undefined') {
-            me.log.debug('Name was not provided, auto-detecting');
-            if (me.root().project) {
-                me.log.debug('Name derived form current project');
-                name = me.root().project;
-            } else {
-                me.log.debug('Name derived from current working directory');
-                name = File.cwd().name;
-            }
-        } else {
-            name = params.identifier;
-            fromUser = true;
-        }
-        return me.startInteractive(name, fromUser);
-    }
-
-    showLogo () {
-        let me = this;
-        let version = me.config.get('pkg').version;
-
-        if (!this._hasShownLogo) {
-            this.log.log(`                      8\u001b[2m${' '.repeat(Math.max(15-version.length-1, 1))+'v'+version}\u001b[22m\nYb  db  dP .d8b. 8d8b 8.dP \u001b[92m.d8b. 8d8b.\u001b[0m\n YbdPYbdP  8' .8 8P   88b  \u001b[92m8' .8 8P Y8\u001b[0m\n  YP  YP   \`Y8P' 8    8 Yb \u001b[92m\`Y8P' 8   8\u001b[0m`);
-            this._hasShownLogo = true;
-        }
-    }
-
-    startInteractive (defaultName, fromUser, showMain = false) {
-        let me = this;
-        let environment = me.root().environment;
-        me.log.debug(`Name '${defaultName}' was${fromUser ? '' : ' not'} provided by the user`);
-        me.log.debug();
-        return inquirer.prompt(me._getFirstQuestion(defaultName, fromUser, showMain)).then(function (answers) {
-            let questions = [];
-            let defaults = me.config.get('project_defaults');
-            let projects = me.config.get('projects');
-            switch (answers.action) {
-                case 'exit':
-                    return true;
-                case 'more': 
-                    return me.startInteractive(defaultName, fromUser, true);
-                case 'init-project':
-                    return inquirer.prompt([{
-                            message: 'What is the name of the project?',
-                            default: defaultName,
-                            name: 'name',
-                            validate: (value) => {
-                                if (value in projects) {
-                                    return 'Project already exists.';
-                                }
-                                if (/\w+#\w+/.test(value)) {
-                                    let projectName = value.substring(0,value.indexOf('#'));
-                                    if (projectName in projects) {
-                                        return true;
-                                    } else {
-                                        return `Project '${projectName}' does not exist. Please create it before starting a branch.`;
-                                    }
-                                } else {
-                                    return true;
-                                }
-                            },
-                            when: (answers) => {
-                                if (fromUser) {
-                                    answers.name = defaultName;
-                                    let prompt = new Prompt({
-                                        type: 'input',
-                                        name: 'name',
-                                        message: `What is the name of the project?`,
-                                        status: 'answered',
-                                        default: answers.name
-                                    });
-                                    return me.log.log(prompt.getQuestion());
-                                } else {
-                                    return true;
-                                }
-                            }
-                        },{
-                            message: 'What is the path to the project?',
-                            default: (answers) => {
-                                if (!/\w+#\w+/.test(answers.name)) {
-                                    return File.from(defaults.base).join(answers.name).path
-                                }    
-                            },
-                            when: (answers) => {
-                                if (/\w+#\w+/.test(answers.name)) {
-                                    let projectName = answers.name.substring(0,answers.name.indexOf('#'));
-                                    answers.path = File.from(defaults.base).join(projects[projectName].path).absolutePath();
-                                    let prompt = new Prompt({
-                                        type: 'input',
-                                        message: `What is the path to the project?`,
-                                        status: 'answered',
-                                        default: answers.path
-                                    });
-                                    return me.log.log(prompt.getQuestion());
-                                } else {
-                                    return true;
-                                }
-                            },
-                            name: 'path',
-                            filter: (answer) => {
-                                let answerFile = File.from(answer);
-                                let defaultBase = File.from(defaults.base);
-                                if (!answerFile.isAbsolute()) {
-                                    answerFile = defaultBase.join(answerFile);
-                                }
-                                try {
-                                    let canonical = answerFile.canonicalize();
-                                    if (canonical) {
-                                        answerFile = canonical;
-                                    } else {
-                                        answerFile = answerFile.absolutify();
-                                    }
-                                } catch (e) {
-                                    answerFile = answerFile.absolutify();
-                                }
-                                return answerFile.relativize(defaultBase.path).path;
-                            }
-                        },{
-                            message: 'What is the IDE?',
-                            type: 'list',
-                            name: 'ide',
-                            choices: [{
-                                name: 'Visual Studio Code',
-                                value: 'vscode'
-                            },{
-                                name: 'IntelliJ IDEA',
-                                value: 'idea'
-                            },{
-                                name: 'Atom',
-                                value: 'atom'
-                            }]
-                        },{
-                            message: 'Which events should take place when opening?',
-                            type: 'checkbox',
-                            name: 'events',
-                            choices: [{
-                                name: 'Change terminal cwd to project path',
-                                value: 'cwd'
-                            }, {
-                                name: 'Open project in IDE',
-                                value: 'ide'
-                            }],
-                            filter: (answer) => {
-                                return {
-                                    cwd: answer.indexOf('cwd') > -1,
-                                    ide: answer.indexOf('ide') > -1
-                                }
-                            }
-                        }]).then((answers) => {
-                            let projects = me.config.get('projects');
-                            projects[answers.name] = {};
-                            deepAssign(projects[answers.name], answers);
-                            delete projects[answers.name].name;
-                            me.config.set('projects', projects);
-
-                            me.log.info(`Your project has been initialized.`);
-                            me.log.info(`Use 'workon ${answers.name}' to start working!`);
-
-                            return true;
-                        });
-                case 'init-branch':
-                    return inquirer.prompt([{
-                            message: 'What is the name of the branch?',
-                            name: 'branch',
-                            validate: (value) => {
-                                if (/\w+#\w+/.test(value)) {
-                                    return 'Branch name can\'t contain the "#" sign';
-                                }
-                                if (`${defaultName}#${value}` in projects) {
-                                    return 'Branch already exists.';
-                                }
-                                return true;
-                            }
-                        }]).then((answers) => {
-                            answers.name = `${defaultName}#${answers.branch}`
-                            let projects = me.config.get('projects');
-                            projects[answers.name] = {};
-                            deepAssign(projects[answers.name], answers, projects[defaultName]);
-                            delete projects[answers.name].name;
-                            me.config.set('projects', projects);
-
-                            me.log.info(`Your project has been initialized.`);
-                            me.log.info(`Use 'workon ${answers.name}' to start working!`);
-
-                            return true;
-                        });
-                case 'switch-project':
-                    me.log.info('Switch to an existing project');
-                break;
-                case 'switch-branch':
-                    me.log.info('Switch to an existing branch');
-                break;
-                case 'manage-projects':
-                    me.log.info('Manage existing projects');
-                break;
-                case 'manage-branches': 
-                    me.log.info('Manage existing branches');
-                break;
-            }
-        });
-    }
-
-    _getFirstQuestion (defaultName, fromUser, showMain) {
-        let me = this;
-        let environment = me.root().environment;
-        if (!showMain && environment.$isProjectEnvironment && !fromUser) {
-            return {
-                type: 'list',
-                name: 'action',
-                message: () => environment.project.name,
-                choices: [{
-                    name: 'Start a branch',
-                    value: 'init-branch'
-                },{
-                    name: 'Switch branch',
-                    value: 'switch-branch'
-                },{
-                    name: 'Manage branches',
-                    value: 'manage-branches'
-                },
-                new inquirer.Separator(),
-                {
-                    name: 'More...',
-                    value: 'more'
-                },{
-                    name: 'Exit',
-                    value: 'exit'
-                }]
-            };
-        } else {
-            return {
-                type: 'list',
-                name: 'action',
-                message: 'What do you want to do?',
-                choices: [{
-                    name: 'Start a new project',
-                    value: 'init-project'
-                },{
-                    name: 'Open an existing project',
-                    value: 'switch-project'
-                },{
-                    name: 'Manage projects',
-                    value: 'manage-projects'
-                },
-                new inquirer.Separator(),{
-                    name: 'Exit',
-                    value: 'exit'
-                }],
-                default: fromUser ? defaultName : undefined,
-                when: (answers) => {
-                    if (fromUser) {
-                        answers.name = 'init-project';
-                        let prompt = new Prompt({
-                            type: 'input',
-                            name: 'name',
-                            message: `What do you want to do?`,
-                            default: 'Start a new project'
-                        });
-                        return me.log.log(prompt.getQuestion());
-                    }
-                    return true;
-                }
-            };
-        }
-    }
-}
-
-interactive.define({
-    parameters: {
-        identifier: {
-            type: 'string',
-            value: ''
-        }
-    }
-});
-
-module.exports = interactive;