jsir 2.1.8 → 2.2.0

package/cmd/oaa.js

@@ -5,16 +5,16 @@ const {
     getCbText, e, sleep, objDataFile, vl, md5, BigNumber,
     arrayDataFile, infoStr, warnStr, errorStack,
     getInfo, ei, pad, msgStr, getType,
-    errorTag, isArgsMatch, draftQuery, setConfig,
+    isArgsMatch, draftQuery, setConfig,
     $log, $draft, getTextComments, getOr, importG, requireG,
-    clearConsole
+    clearConsole, trimText
 } = $lib;
 const _args = process.argv.slice(2).map(trim);
 const evalCode = require('../deps/evalCode')
 const {evalVal} = require('../deps/cleanEval')
 const _chokidar = require('chokidar');
 const setting = require('../deps/setting')
-const _fs = require('fs')
+const fs = require('fs')
 const readline = require("readline");
 const packageJson = require("../package.json");
 const example = require("../deps/example");
@@ -31,57 +31,70 @@ const $config = {
     get: getConfig,
     set: setConfig
 }
-const CONSOLE = Object.assign({}, console);
-const info = (msg) => $lib.info(msg, CONSOLE);
-const warn = (msg) => $lib.warn(msg, CONSOLE);
-const error = (msg, tag) => $lib.error(msg, tag, CONSOLE);
+const console = Object.assign({}, global.console);
 
+let lastFilterArg = '';
 let _cmdMapFile = setting.name + 'CmdMap.json'
 let _cmdMap = {}
 let _rl
 let _rlHistory = []
 let _haveWrapperInput = true
 let _noAppendNextLine = true
+let _onLazyTempCode = null
 
 const _onLazyGetMap = {}
 const _data = {}
 const _lazyTime = 5 * 60 * 1000
-const _dealOnLazyGet = (key) => {
+const _dealOnLazyGet = (key, onLazyTempCode) => {
     if (_noAppendNextLine || !_onLazyGetMap[key]) {
         return _data[key]
     }
-    let item = _onLazyGetMap[key]
-    if (Date.now() <= item.startTime) {
-        item.startTime = Date.now() + _lazyTime
-        return _data[key]
-    }
-    let flag = _onLazyGetMap[key].fn()
-    if (getType(flag)=== 'Promise') {
-        return new Promise(async (resolve, reject) => {
-            try {
-                await flag
-                item.startTime = Date.now() + _lazyTime
-                resolve(_data[key])
-            } catch (e) {
-                reject(e)
-            }
-        })
-    } else {
-        item.startTime = Date.now() + _lazyTime
+    if (Date.now() <= _onLazyGetMap[key]) {
+        _onLazyGetMap[key] = Date.now() + _lazyTime
         return _data[key]
     }
+    return new Promise(async (resolve, reject) => {
+        let inputCode = onLazyTempCode || await nextLine(i => i, "TEMP_CODE: ", true)
+        if (inputCode !== _onLazyTempCode) {
+            reject("tempCode check failed")
+        } else {
+            _onLazyGetMap[key] = Date.now() + _lazyTime
+            resolve(_data[key])
+        }
+    })
 }
-const _dataSet = (key, val, onLazyGet) => {
-    if (onLazyGet) {
-        _onLazyGetMap[key] = {
-            fn: onLazyGet,
-            startTime: Date.now() + _lazyTime
+
+const _dataSet = (key, val, onLazyTempCode) => {
+    let useOnLazy = false;
+    if (typeof onLazyTempCode === 'string') {
+        useOnLazy = true
+        if (!vl(_onLazyTempCode)) {
+            _onLazyTempCode = trim(onLazyTempCode);
+        }
+    } else if (true === onLazyTempCode) {
+        useOnLazy = true
+    } else if (onLazyTempCode !== undefined) {
+        throw "invalid tempCode defined"
+    }
+    if (useOnLazy) {
+        _onLazyGetMap[key] = Date.now() + _lazyTime
+        if (!vl(_onLazyTempCode)) {
+            return new Promise(async (resolve, reject) => {
+                let tempCode = await nextLine(i => i, "SET TEMP_CODE: ", true)
+                if (vl(tempCode)) {
+                    _onLazyTempCode = trim(tempCode);
+                    resolve(_data[key] = val)
+                } else {
+                    reject("invalid tempCode")
+                }
+            });
         }
     }
+
     return _data[key] = val
 }
 const $data = {
-    get: (key, defaultVal) => {
+    get: (key, defaultVal, onLazyTempCode) => {
         if (!vl(_data[key])) {
             if (defaultVal !== undefined) {
                 return defaultVal
@@ -89,17 +102,17 @@ const $data = {
                 return _data[key]
             }
         }
-        return _dealOnLazyGet(key)
+        return _dealOnLazyGet(key, onLazyTempCode)
     },
-    gos: (key, defaultVal, onLazyGet) => {
+    gos: (key, defaultVal, onLazyTempCode) => {
         if (!vl(_data[key])) {
             if (defaultVal !== undefined) {
-                return _dataSet(key, defaultVal, onLazyGet)
+                return _dataSet(key, defaultVal, onLazyTempCode)
             } else {
                 return _data[key]
             }
         }
-        return _dealOnLazyGet(key)
+        return _dealOnLazyGet(key, onLazyTempCode)
     },
     set: _dataSet,
     del: (key) => {
@@ -124,7 +137,7 @@ function getFileOpenExe(fileName) {
     if (strs.length > 1) {
         suffix = strs[strs.length - 1]
     }
-    let defaultExe = getConfig("defaultExe", "idea");
+    let defaultExe = getConfig("defaultExe", "open");
     if (!suffix) {
         return defaultExe
     }
@@ -143,7 +156,7 @@ function checkWorkspaces() {
         if (space === 'local') {
             continue
         }
-        if (_fs.existsSync(workspace)) {
+        if (fs.existsSync(workspace)) {
             $workspaceMap[space] = workspace;
         }
     }
@@ -154,7 +167,8 @@ function checkWorkspaces() {
 async function start() {
     checkWorkspaces()
 
-    _cmdMap = objDataFile(_cmdMapFile)
+    lastFilterArg = getConfig("lastFilterArg");
+    _cmdMap = objDataFile(_cmdMapFile);
     if (_args[0]) {
         let line = _args.map(i => {
             if (/\s+/.test(i) || !i) {
@@ -169,11 +183,11 @@ async function start() {
 }
 
 async function getFileWatcher(workFilePath, text) {
-    info("workFile open " + workFilePath)
+    console.info("workFile open " + workFilePath)
     if (!_fileWatcherMap[workFilePath]) {
-        _fs.unlinkSync(workFilePath)
+        fs.unlinkSync(workFilePath)
         await sleep(1000)
-        _fs.writeFileSync(workFilePath, text)
+        fs.writeFileSync(workFilePath, text)
         let watcher = _chokidar.watch([workFilePath]);
         _fileWatcherMap[workFilePath] = watcher;
         setTips("FILE", null, () => {
@@ -185,7 +199,7 @@ async function getFileWatcher(workFilePath, text) {
 
 function closeFileWatcher(workFilePath) {
     let watcher = _fileWatcherMap[workFilePath]
-    info("workFile close " + workFilePath)
+    console.info("workFile close " + workFilePath)
     watcher.unwatch([workFilePath])
     watcher.close()
     delete _fileWatcherMap[workFilePath]
@@ -201,23 +215,23 @@ async function workFile(uniqueName) {
 
 async function watchFile(uniqueName) {
     let workFilePath = getFullPath(uniqueName);
-    if (!_fs.existsSync(workFilePath)) {
-        _fs.writeFileSync(workFilePath, '');
+    if (!fs.existsSync(workFilePath)) {
+        fs.writeFileSync(workFilePath, '');
     }
-    let text = String(_fs.readFileSync(workFilePath))
+    let text = String(fs.readFileSync(workFilePath))
     let watcher = await getFileWatcher(workFilePath, text)
 
     if (watcher) {
         watcher.on('change', async () => {
-            let newText = String(_fs.readFileSync(workFilePath));
+            let newText = String(fs.readFileSync(workFilePath));
             let exeStr = getExeStr(text, newText);
             text = newText;
             if (trim(exeStr)) {
                 try {
-                    CONSOLE.log("\n" + infoStr("------ workFile run ------"))
+                    console.log("\n" + infoStr("------ workFile run ------"))
                     await wrapperInput("# " + exeStr)
                 } catch (e) {
-                    error(e)
+                    console.error(e)
                 }
             }
         }).on("unlink", () => {
@@ -383,7 +397,7 @@ function _nextLine(callback, promptStr, hidden, resolve, end, isText) {
             closeRl()
             inputStr = inputStr.replace(/\s+$/, '');
             if (!isText && /^\d+$/.test(inputStr) && /^\s+/.test(textLine)) {
-                inputStr = "& " + inputStr;
+                inputStr = '.e ' + inputStr;
             }
             let pro = (callback || wrapperInput)(inputStr);
             resolve && resolve(inputStr);
@@ -393,12 +407,8 @@ function _nextLine(callback, promptStr, hidden, resolve, end, isText) {
                 if ((callback || wrapperInput) === wrapperInput) {
                     if (!_noAppendNextLine) {
                         if (/^\s+$/.test(textLine)) {
-                            if (textLine.length > 1) {
-                                clearConsole(false)
-                            } else {
-                                clearConsole();
-                            }
-                            listCmd();
+                            clearConsole(textLine.length - 1)
+                            filterCmdAndList();
                             nextLine(null, defaultPromptStr(true))
                         } else {
                             nextLine()
@@ -423,11 +433,11 @@ async function nextText(callback, end, hidden) {
 async function save(args) {
     let uniqueName = toUniqueName(toJsirFileName(args.join(' ')))
     let path = getFullPath(uniqueName)
-    if (_fs.existsSync(path)) {
-        warn(`${path} already exist`)
-        _cmdMap = {
+    if (fs.existsSync(path)) {
+        console.warn(`${path} already exist`)
+        resetCmdMap({
             1:  uniqueName
-        }
+        });
         listCmd()
         return
     }
@@ -439,26 +449,31 @@ async function save(args) {
     } else {
         resp = await getCbText();
     }
-    _fs.writeFileSync(path, resp)
-    info(`${path} created`)
-    _cmdMap = {
+    fs.writeFileSync(path, resp)
+    console.info(`${path} created`)
+    resetCmdMap({
         1:  uniqueName
-    }
+    });
     listCmd()
 }
 
+function resetCmdMap(cmdMap = {}) {
+    lastFilterArg = '';
+    _cmdMap = cmdMap;
+}
+
 function rename(dir, oldName, newName) {
     let old = dir + '/' + oldName;
     let _new = dir + '/' + newName;
-    if (_fs.existsSync(_new)) {
-        warn(`${_new} already exist`)
+    if (fs.existsSync(_new)) {
+        console.warn(`${_new} already exist`)
     } else {
-        _fs.renameSync(old, _new)
-        info(`${_new} renamed`)
+        fs.renameSync(old, _new)
+        console.info(`${_new} renamed`)
     }
-    _cmdMap = {
+    resetCmdMap({
         1:  toUniqueName(_new)
-    }
+    });
     listCmd()
 }
 
@@ -471,7 +486,7 @@ function listCmd(tmpMap) {
     }
 
     tmpMap = arrayToCmdMap(Object.values(tmpMap)
-        .filter(item => _fs.existsSync(getFullPath(item)))
+        .filter(item => fs.existsSync(getFullPath(item)))
         .sort((a,b) => {
             a = parseUniqueName(a)[1];
             b = parseUniqueName(b)[1];
@@ -492,7 +507,7 @@ function listCmd(tmpMap) {
 
     let items = []
     for (let i of Object.keys(tmpMap)) {
-        let text = String(_fs.readFileSync(getFullPath(tmpMap[i])))
+        let text = String(fs.readFileSync(getFullPath(tmpMap[i])))
         let pair = parseUniqueName(tmpMap[i])
         let name = trimJsirFileName(pair[1])
         let suffix = getJsirFileSuffix(pair[1])
@@ -504,12 +519,12 @@ function listCmd(tmpMap) {
         items.push(item)
 
         if (!text) {
-            text = String(_fs.readFileSync(getFullPath(tmpMap[i])))
+            text = String(fs.readFileSync(getFullPath(tmpMap[i])))
         }
         getComments(i, tmpMap[i], text, items, item)
     }
     if (Object.keys(items).length === 0) {
-        warn("no items")
+        console.warn("no items")
     } else {
         items.forEach(item => {
             if (tmpList && item.key) {
@@ -527,7 +542,7 @@ function listCmd(tmpMap) {
                 item.name = pair[0] + '/' + item.name
             }
         })
-        CONSOLE.table(items)
+        console.table(items)
     }
 }
 
@@ -535,10 +550,14 @@ async function wrapperInput(str) {
     try {
         await _wrapperInput(str);
     } catch (e) {
-        error(e)
+        console.error(e)
     }
 }
 
+function getEditor() {
+    return getConfig("defaultEditor", "vi")
+}
+
 async function _wrapperInput(str) {
     _haveWrapperInput = true;
     global.$newInput = true;
@@ -547,20 +566,7 @@ async function _wrapperInput(str) {
     if (!str) {
         return;
     }
-    if (/^&/.test(str)) {
-        let cmdStr = trim(str.substr(1));
-        if (/^\d+$/.test(cmdStr)) {
-            if (_cmdMap[cmdStr]) {
-                ei('vi', [getFullPath(_cmdMap[cmdStr])])
-            } else {
-                ei('vi', ['-n'])
-            }
-        } else if (cmdStr) {
-            ei(cmdStr.split(/\s+/)[0], enrichArgs(trim(cmdStr.replace(/^\S+/, ''))).map(trim));
-        } else {
-            ei('vi', ['-n'])
-        }
-    } else if (/^[`'"]/.test(str)) {
+    if (/^[`'"]/.test(str)) {
         let fstr = str.substr(0, 1);
         if (fstr === '`') {
             let text = str.substr(1) + "\n" + await nextText(line => line, fstr)
@@ -568,7 +574,7 @@ async function _wrapperInput(str) {
         } else {
             let fLine = trim(str.substr(1))
             if (fLine) {
-                CONSOLE.log(draftQuery(fLine).join("\n"))
+                console.log(draftQuery(fLine).join("\n"))
             } else {
                 let text = str.substr(1) + "\n" + await nextText(line => line, fstr)
                 $draft(text)
@@ -579,33 +585,16 @@ async function _wrapperInput(str) {
         let isStar =  str.startsWith('*')
         let text = trim(str.replace(/^[$#*]/, ''))
         if (is$) {
-            CONSOLE.log(await evalText('return ' + text))
+            console.log(await evalText('return ' + text))
         } else if (isStar) {
-            if (!text) {
-                text = '$context';
-            }
-            let result = await evalText('return ' + text)
-            if (!result || typeof result === 'string' || Object.keys(result).length === 0) {
-                CONSOLE.nable([getInfo(result)])
-                return
-            }
-            let rows = []
-            for (let key of Object.keys(result)) {
-                rows.push(getInfo(result[key], key))
-            }
-            if (rows.length === 0) {
-                warn("no items")
-            } else {
-                CONSOLE.nable(rows)
-            }
+            await dealStar(text)
         } else {
             await evalText(text)
         }
     } else if (str.match(/^\./)) {
         await dealKeyword(enrichArgs(str))
     } else if (!str.split(/\s+/)[0].match(/^\d+$/)) {
-        _cmdMap = arrayToCmdMap(filterCmd(str))
-        listCmd()
+        filterCmdAndList(str);
     } else {
         let strs = str.split(/\s+/)
         if (_cmdMap[strs[0]]) {
@@ -616,7 +605,7 @@ async function _wrapperInput(str) {
             if (firstName === 'f') {
                 await workFile(uniqueName)
             } else if (firstName !== 'e') {
-                CONSOLE.log(String(_fs.readFileSync(path)));
+                console.log(String(fs.readFileSync(path)));
             } else {
                 await runCmd(str)
             }
@@ -626,6 +615,143 @@ async function _wrapperInput(str) {
     }
 }
 
+async function dealStartGlobalMode(rows, items, text) {
+    console.info('global search mode');
+    rows.push(...await dealStarCase(await evalText('return $context'), items, '$context'))
+    rows.push(...await dealStarCase(global, items, 'global'))
+    rows.push(...await dealStarCase($lib, items, '$lib'))
+    rows.push(...dealStarGlobal(items, text))
+}
+
+async function dealStar(text) {
+    if (!text) {
+        text = '$context';
+    }
+    let items = text.split(/\s+/);
+    let rows = []
+    if (_cmdMap[items[0]]) {
+        rows.push(...await dealStarCmd([], _cmdMap[items[0]], '.'))
+    } else if (items[0].indexOf("/") !== -1) {
+        await dealStartGlobalMode(rows, items, text);
+    } else {
+        try {
+            let result = await evalText(`return ${items[0]}`)
+            rows.push(...await dealStarCase(result, items.slice(1)))
+        } catch (e) {
+            await dealStartGlobalMode(rows, items, text);
+        }
+    }
+    if (rows.length === 0) {
+        console.warn("no items")
+    } else {
+        console.nable(rows)
+    }
+}
+
+function dealStarGlobal(items, text) {
+    let rows = []
+    let prefix = ''
+    let index = items[0].indexOf("/");
+    if (index !== -1) {
+        prefix = trim(items[0].substring(0, index + 1))
+        text = trim(text.substring(index + 1))
+    }
+    for (let cmd of filterCmd(prefix + '^i ,')) {
+        dealStarCmd(rows, cmd, text)
+    }
+    return rows;
+}
+
+function dealStarCmd(rows, cmd, filterStr) {
+    let content = String(fs.readFileSync(getFullPath(cmd)));
+    let capturingFunction = false;
+    let inMultiLineComment = false;
+    let potentialComments = [];
+    let functionLines = [];
+    let comments = [];
+    let fnName = '';
+    let fnType = '';
+
+    // Helper function to reset state
+    function resetState() {
+        capturingFunction = false;
+        fnName = '';
+        fnType = '';
+        functionLines = [];
+        potentialComments = [];
+        comments = [];
+    }
+
+    for (let line of content.split('\n')) {
+        // Handle multi-line comment start or continue
+        if (line.trim().startsWith('/*') || inMultiLineComment) {
+            inMultiLineComment = true;
+            potentialComments.push(line);
+
+            // Check for multi-line comment end
+            if (line.trim().endsWith('*/')) {
+                inMultiLineComment = false;
+            }
+            continue; // Continue to the next line
+        }
+
+        // Capture single-line comments
+        if (line.trim().startsWith('//')) {
+            potentialComments.push(line);
+        }
+
+        // Check for function start
+        if ((line.startsWith('function') || line.startsWith('async function')) && isArgsMatch(line, [filterStr])) {
+            fnName = reget(line, /function\s+(\w+)\s*\(/);
+            fnType = line.startsWith('async') ? 'AsyncFunction' : 'Function';
+            capturingFunction = true;
+            comments = [...potentialComments]; // Confirm the comments are related to the function
+            potentialComments = []; // Clear the potential comments as they are now confirmed
+        }
+
+        // Capture function lines
+        if (capturingFunction) {
+            functionLines.push(line);
+        }
+
+        // Check for function end and process
+        if (fnName && line.startsWith("}") && capturingFunction) {
+            let functionContent = functionLines.join('\n');
+            let commentContent = trimText(comments.join('\n'));
+            let row = getInfo(functionContent, fnName, fnType);
+            row.value = infoStr(cmd) + ' ' + getCmdMd5Key(parseUniqueName(cmd)[1]) + '\n' + [commentContent, row.value].filter(i => trim(i)).join("\n");
+            rows.push(row);
+
+            resetState();
+        }
+
+        // If not capturing function, reset potential comments
+        if (!capturingFunction && !inMultiLineComment && line.trim() !== '' && !line.trim().startsWith('//')) {
+            potentialComments = [];
+        }
+    }
+    return rows;
+}
+
+async function dealStarCase(result, matchStrs, cmd) {
+    let rows = []
+    if (!result || typeof result === 'string' || Object.keys(result).length === 0) {
+        rows.push(getInfo(result))
+    } else {
+        for (let key of Object.keys(result)) {
+            if (matchStrs.length === 0 || isArgsMatch(key, [matchStrs.join(' ')])){
+                rows.push(getInfo(result[key], key))
+            }
+        }
+    }
+    if (cmd) {
+        for (let row of rows) {
+            row.value = infoStr(cmd) + '\n' + row.value;
+        }
+    }
+    return rows;
+}
+
 function arrayToCmdMap(cmds) {
     let cmdMap = {}
     for (let i = 0; i < cmds.length; i++) {
@@ -634,8 +760,8 @@ function arrayToCmdMap(cmds) {
     return cmdMap
 }
 
-function help() {
-    CONSOLE.nable(Object.keys(keywordDef).map(key => {
+function help(filterFn) {
+    console.nable(Object.keys(keywordDef).filter(i => filterFn ? filterFn(i):true).map(key => {
         let item = keywordDef[key];
         return {
             keyword: ' ' + warnStr(`.${key}`),
@@ -661,19 +787,23 @@ function delTipsByIndex(idxs) {
             params.push(indexKeyMap[keys.length + 1 + Number(index)])
         }
     }
+    if (idxs.length > 0 && params.length <= 0) {
+        console.warn("no items")
+        return;
+    }
     delTips(...params)
 }
 
 function copyToSpace(uniqueName) {
     let path = getFullPath(uniqueName)
-    let text = String(_fs.readFileSync(path))
+    let text = String(fs.readFileSync(path))
     let fileName = parseUniqueName(uniqueName)[1];
     let targetPath = $workspaceMap[$defaultSpace] + '/' + fileName;
-    if (_fs.existsSync(targetPath)) {
-        warn(`${fileName} already exist in ${$defaultSpace}`)
+    if (fs.existsSync(targetPath)) {
+        console.warn(`${fileName} already exist in ${$defaultSpace}`)
     } else {
-        _fs.writeFileSync(targetPath, text)
-        info(`get ${uniqueName} to ${$defaultSpace}`)
+        fs.writeFileSync(targetPath, text)
+        console.info(`get ${uniqueName} to ${$defaultSpace}`)
     }
 }
 
@@ -696,7 +826,7 @@ let compareMode = {
         }
         return result
     },
-    'ab=': (aSpace, bSpace, a, b, as, bs) => {
+    'ab=': (aSpace, bSpace, as, bs) => {
         let result = []
         for (let a of as) {
             if (bs.indexOf(a) !== -1) {
@@ -748,20 +878,10 @@ const keywordDef = {
         },
         short: 'h'
     },
-    version: {
-        comment: 'View version',
-        exeFn: (args) => {
-            CONSOLE.log(packageJson.version)
-        },
-        short: 'v'
-    },
     list: {
         comment: 'View file list',
         exeFn: (args) => {
-            if (args.length > 0) {
-                _cmdMap = arrayToCmdMap(filterCmd(args.length > 0 ? args.join(' '):[',']))
-            }
-            listCmd()
+            filterCmdAndList(args.length > 0 ? args.join(' '):'');
         },
         args: {
             queryParams: 'string matching, [,] represents all, keywords can be omitted'
@@ -778,22 +898,22 @@ const keywordDef = {
         },
         short: 'C'
     },
-    see: {
+    view: {
         comment: 'View file',
         exeFn: (args) => {
             let uniqueName = _cmdMap[args[0]]
             if (!uniqueName) {
-                warn("no items")
+                console.warn("no items")
             } else {
                 let path = getFullPath(uniqueName)
-                let sourceStr = String(_fs.readFileSync(path))
-                CONSOLE.log(sourceStr)
+                let sourceStr = String(fs.readFileSync(path))
+                console.log(sourceStr)
             }
         },
         args: {
             fileIndex: 'File index'
         },
-        short: 's'
+        short: 'v'
     },
     rm: {
         comment: 'Remove file',
@@ -802,15 +922,15 @@ const keywordDef = {
             if (args[0] === 'ALL') {
                 for (let value of Object.values(_cmdMap)) {
                     let path = getFullPath(value)
-                    _fs.unlinkSync(path)
-                    info(`${path} removed`)
+                    fs.unlinkSync(path)
+                    console.info(`${path} removed`)
                 }
             } else if (!uniqueName) {
-                warn("no items")
+                console.warn("no items")
             } else {
                 let path = getFullPath(uniqueName)
-                _fs.unlinkSync(path)
-                info(`${path} removed`)
+                fs.unlinkSync(path)
+                console.info(`${path} removed`)
             }
         },
         args: {
@@ -827,7 +947,7 @@ const keywordDef = {
                     copyToSpace(value)
                 }
             } else if (!uniqueName) {
-                warn("no items")
+                console.warn("no items")
             } else {
                 copyToSpace(uniqueName)
             }
@@ -842,7 +962,7 @@ const keywordDef = {
         exeFn: (args) => {
             let uniqueName = _cmdMap[args[0]]
             if (!uniqueName) {
-                warn("no items")
+                console.warn("no items")
             } else {
                 let pair = parseUniqueName(uniqueName)
                 let newName =trim(args.slice(1).join(" "))
@@ -860,10 +980,10 @@ const keywordDef = {
         exeFn: async (args) => {
             let uniqueName = _cmdMap[args[0]]
             if (!uniqueName) {
-                warn("no items")
+                console.warn("no items")
             } else {
                 let path = getFullPath(uniqueName)
-                await e(`"${getFileOpenExe(parseUniqueName(uniqueName)[1])}" "${path}"`)
+                ei(getEditor(), [path])
             }
         },
         args: {
@@ -871,6 +991,29 @@ const keywordDef = {
         },
         short: 'e'
     },
+    setting: {
+        comment: 'Global settings',
+        exeFn: async (args) => {
+            ei(getEditor(), [`${getLibDataDir()}/config.json`])
+        },
+        short: 's'
+    },
+    open: {
+        comment: 'open file',
+        exeFn: async (args) => {
+            let uniqueName = _cmdMap[args[0]]
+            if (!uniqueName) {
+                console.warn("no items")
+            } else {
+                let path = getFullPath(uniqueName)
+                await e(`"${getFileOpenExe(parseUniqueName(uniqueName)[1])}" "${path}"`)
+            }
+        },
+        args: {
+            fileIndex: 'File index'
+        },
+        short: 'o'
+    },
     compare: {
         comment: 'Compare files',
         exeFn: async (args) => {
@@ -880,27 +1023,30 @@ const keywordDef = {
             let bSpace = args[1]
 
             if (aUniqueName && bUniqueName) {
-                await e(`${getConfig("compareExe", "idea diff")} "${getFullPath(aUniqueName)}" "${getFullPath(bUniqueName)}"`)
+                let result = await e(`${getConfig("compareExe", "diff")} "${getFullPath(aUniqueName)}" "${getFullPath(bUniqueName)}"`)
+                if (result) {
+                    console.log(result)
+                }
             } else if (aSpace && bSpace) {
                 if (!args[2]) {
-                    warn('require mode')
+                    console.warn('require mode')
                     return
                 }
 
                 let mode = args[2]
                 if (Object.keys(compareMode).indexOf(mode) === -1) {
-                    warn('invalid mode')
+                    console.warn('invalid mode')
                     return;
                 }
 
-                let aFiles = _fs.readdirSync($workspaceMap[aSpace]).filter(isJsirFileName)
-                let bFiles = _fs.readdirSync($workspaceMap[bSpace]).filter(isJsirFileName)
+                let aFiles = fs.readdirSync($workspaceMap[aSpace]).filter(isJsirFileName)
+                let bFiles = fs.readdirSync($workspaceMap[bSpace]).filter(isJsirFileName)
 
                 let result = compareMode[mode](aSpace, bSpace, aFiles, bFiles);
-                _cmdMap = arrayToCmdMap(result)
+                resetCmdMap(arrayToCmdMap(result))
                 listCmd()
             } else {
-                warn('invalid args')
+                console.warn('invalid args')
             }
         },
         args: {
@@ -915,23 +1061,38 @@ const keywordDef = {
         exeFn: (args) => {
             let uniqueName = _cmdMap[args[0]]
             if (!uniqueName) {
-                warn("no items")
+                console.warn("no items")
             } else {
                 let cmds = getScriptRequires(uniqueName);
-                _cmdMap = arrayToCmdMap([uniqueName, ...cmds])
+                resetCmdMap(arrayToCmdMap([uniqueName, ...cmds]))
                 listCmd()
 
+                let packages = []
                 for (let un of [uniqueName, ...cmds]) {
                     let path = getFullPath(un);
-                    let text = removeComment(String(_fs.readFileSync(path)))
-
-                    preLoad(text, "[\\s=;]require", requireG);
-                    preLoad(text, "^require", requireG);
+                    let text = removeComment(String(fs.readFileSync(path)))
 
-                    preLoad(text, "\\$import", importG);
-                    preLoad(text, "[\\s=;]import", importG);
-                    preLoad(text, "^import", importG);
+                    preLoad(text, "[\\s=;]require", requireG, packages)
+                    preLoad(text, "^require", requireG, packages)
+                    preLoad(text, "\\$import", importG, packages)
+                    preLoad(text, "[\\s=;]import", importG, packages)
+                    preLoad(text, "^import", importG, packages)
                 }
+                let moduleDir = $workspaceMap[global.$defaultSpace] + '/node_modules'
+                let deps = {}
+                packages.forEach(name => {
+                    if (deps[name]) {
+                        return;
+                    }
+                    let dir = moduleDir + "/" + name;
+                    if (fs.existsSync(dir) && fs.existsSync(dir + '/package.json')) {
+                        deps[name] = require(dir + '/package.json').version;
+                    } else {
+                        deps[name] = 'Unknown';
+                    }
+                })
+                console.info("package version")
+                console.log(JSON.stringify(deps, null, 2))
             }
         },
         args: {
@@ -947,7 +1108,7 @@ const keywordDef = {
             } else {
                 let name = _cmdMap[args[0]]
                 if (!name) {
-                    warn("no items")
+                    console.warn("no items")
                 } else {
                     await watchFile(name)
                 }
@@ -963,73 +1124,34 @@ const keywordDef = {
         exeFn: async (args) => {
             let newWorkspace = args.join(' ')
             if (newWorkspace) {
-                let workspaces = Object.values($workspaceMap)
-                workspaces.push(newWorkspace)
-                arrayDataFile(_workspaceConfigFile, () => workspaces)
+                if ($workspaceMap[newWorkspace]) {
+                    initWorkspace(newWorkspace)
+                } else if (newWorkspace.startsWith('-')) {
+                    let name = newWorkspace.replace(/^-\s*/, '');
+                    arrayDataFile(_workspaceConfigFile, arr => arr.filter(path => name !== getSpaceFromDir(path)))
+                } else if (newWorkspace.startsWith("/")) {
+                    let workspaces = Object.values($workspaceMap)
+                    workspaces.push(newWorkspace)
+                    arrayDataFile(_workspaceConfigFile, () => workspaces)
+                } else {
+                    console.warn('invalid args')
+                }
             }
             checkWorkspaces()
             let workspaces = Object.values($workspaceMap)
             let items = workspaces.map((path, index) => {
                 return {
-                    index: ' ' + (index + 1),
-                    name: getSpaceFromDir(path),
+                    name: (getSpaceFromDir(path) === $defaultSpace ? '*':' ') + getSpaceFromDir(path),
                     path
                 }
             })
-            CONSOLE.table(items)
+            console.table(items)
         },
         args: {
             workspacePath: 'New workspace path'
         },
         short: 'w'
     },
-    uninstall: {
-        comment: 'Uninstall workspace',
-        exeFn: async (args) => {
-            let workspaces = Object.values($workspaceMap)
-            let items = workspaces.map((path, index) => {
-                return {
-                    index: ' ' + (index + 1),
-                    name: getSpaceFromDir(path),
-                    path
-                }
-            })
-            CONSOLE.table(items)
-            let index = await nextLine(line => line, "index: ")
-            let workspace = workspaces[index - 1]
-            if (workspace) {
-                workspaces = workspaces.filter(i => i !== workspace);
-                arrayDataFile(_workspaceConfigFile, () => workspaces);
-                checkWorkspaces()
-            } else {
-                warn('invalid args')
-            }
-        },
-        short: 'u'
-    },
-    switch: {
-        comment: 'Switch workspace',
-        exeFn: async (args) => {
-            checkWorkspaces()
-            let workspaces = Object.values($workspaceMap)
-            let items = workspaces.map((path, index) => {
-                return {
-                    index: ' ' + (index + 1),
-                    name: getSpaceFromDir(path),
-                    path
-                }
-            })
-            CONSOLE.table(items)
-            let index = trim(await nextLine(line => line, "switch workspace: "));
-            if (index && workspaces[index - 1]) {
-                let workspace = workspaces[index - 1];
-                initWorkspace(getSpaceFromDir(workspace))
-            } else {
-                warn('no items')
-            }
-        },
-        short: 'S'
-    },
     add: {
         comment: 'Add file',
         exeFn: async (args) => {
@@ -1044,7 +1166,7 @@ const keywordDef = {
         comment: 'Quick execution',
         exeFn: async (args) => {
             if (!args[0]) {
-                warn('invalid args')
+                console.warn('invalid args')
                 return
             }
             let keyword = args[0]
@@ -1052,13 +1174,20 @@ const keywordDef = {
             if (keyword.endsWith('.')) {
                 let _tmp = trim(keyword.substring(0, keyword.length - 1));
                 if (_tmp) {
+                    if (keywordDef[_tmp] || Object.values(keywordDef).map(item => item.short).indexOf(_tmp) !== -1) {
+                        help(i => i === _tmp || keywordDef[i].short === _tmp);
+                        return;
+                    }
                     justList = true;
                     keyword = _tmp;
+                } else {
+                    console.warn('invalid keyword')
+                    return
                 }
             }
             let pair = parseUniqueName(keyword)
             let cmds;
-            if (/^0x[a-z\d]{8}$/.test(pair[1]) || pair[1].indexOf(",") !== -1) {
+            if (isMd5Key(pair[1]) || pair[1].indexOf(",") !== -1) {
                 cmds = getQuickRunCmds(keyword, keyword)
             } else {
                 cmds = getQuickRunCmds(keyword, '^e ' + toJsirFileName(pair[1]) + '$')
@@ -1073,7 +1202,7 @@ const keywordDef = {
                     await runScript(cmds[0], args.slice(1))
                 }
             } else {
-                warn(cmds.length > 1 ? "multiple match" : "no match")
+                console.warn(cmds.length > 1 ? "multiple match" : "no match")
             }
         },
         args: {
@@ -1085,8 +1214,8 @@ const keywordDef = {
         comment: 'Exit',
         exeFn: (args) => {
             delTips();
-            CONSOLE.log(infoStr("Bye!"))
-            process.exit(0)
+            console.log(infoStr("Bye!"));
+            _noAppendNextLine = true;
         },
         short: 'q'
     },
@@ -1094,10 +1223,24 @@ const keywordDef = {
         comment: 'Interactive interface',
         exeFn: (args) => {
             _noAppendNextLine = false
-            _cmdMap = {}
-            CONSOLE.log(warnStr("You can start with .help, use * to expand context"))
+            resetCmdMap()
+            console.log(warnStr(`(${setting.name} ${packageJson.version}) You can start with .help, use * to expand context.`))
         },
         short: 'p'
+    },
+    npm: {
+        comment: 'Node npm',
+        exeFn: (args) => {
+            let packageFile = $workspaceMap[global.$defaultSpace] + '/package.json';
+            if(!fs.existsSync(packageFile)) {
+                let jsonObj = {
+                    "dependencies": {}
+                }
+                fs.writeFileSync(packageFile, JSON.stringify(jsonObj, null, 2));
+            }
+            ei(`cd "${$workspaceMap[global.$defaultSpace]}";npm ${args.join(' ')}`, [], true)
+        },
+        short: 'N'
     }
 }
 
@@ -1111,18 +1254,28 @@ function getQuickRunCmds(input, matchStr) {
     return filterCmd(matchStr).filter(i => parseUniqueName(i)[1].startsWith("e "))
 }
 
-function preLoad(text, fnNameMatch, fn) {
+function preLoad(text, fnNameMatch, fn, packages = []) {
     regEach(text, new RegExp(`${fnNameMatch}\\s*\\(([^()]+)\\)`, 'g'), r=> {
         let item = trim(r[1])
         if (item) {
             try {
-                let result = fn(evalVal(item))
+                let packageName = evalVal(item);
+                if (packages.indexOf(packageName) !== -1) {
+                    return;
+                }
+                packages.push(packageName)
+                let result = fn(packageName)
                 if (getType(result) === 'Promise') {
-                    result.catch(e => {})
+                    result.catch(e => {
+                        $log(e)
+                    })
                 }
-            } catch (e) {}
+            } catch (e) {
+                $log(e)
+            }
         }
     });
+    return packages;
 }
 
 async function dealKeyword(items) {
@@ -1195,7 +1348,7 @@ function removeComment(text) {
 
 function _getScriptRequires(uniqueName, cmds, links) {
     let path = getFullPath(uniqueName);
-    let text = removeComment(String(_fs.readFileSync(path)))
+    let text = removeComment(String(fs.readFileSync(path)))
     let temp = []
     regEach(text, /\$require\s*\(([^()]+)\)/g, r=> {
         if (r[1]) {
@@ -1245,7 +1398,7 @@ function getComments(i, cmdName, text, cols = [], col) {
     let docLines = [getCmdMd5Key(parseUniqueName(cmdName)[1]) + " - " + i]
     text = trim(text)
     docLines.push(...getTextComments(text))
-    let argDef = getArgDef(text)
+    let argDef = getArgDef(text, cmdName)
     let comments = getArgComments(argDef, true)
     if (comments) {
         docLines.push(...comments)
@@ -1284,7 +1437,7 @@ function getFullPath(name) {
 function toUniqueName(name, space) {
     name = trim(name)
     if (!name) {
-        throw `invalid name`
+        throw `invalid name '${name}'`
     }
     let uniqueName
     if (name.startsWith('/')) {
@@ -1302,14 +1455,14 @@ function toUniqueName(name, space) {
 function toJsirFileName(name) {
     name = trim(name)
     if (!name) {
-        throw `invalid name`
+        throw `invalid name '${name}'`
     }
     if (isJsirFileName(name)) {
         return name;
     }
     name = name + '.js'
     if (!isJsirFileName(name)) {
-        throw `invalid name`
+        throw `invalid name '${name}'`
     }
     return name
 }
@@ -1346,15 +1499,32 @@ function initWorkspace(space) {
     global.$defaultSpace = workspace;
 }
 
+function filterCmdAndList(arg) {
+    arg = trim(arg) || lastFilterArg;
+    if (arg) {
+        if (lastFilterArg !== arg) {
+            lastFilterArg = arg;
+            if (_noAppendNextLine) {
+                setConfig("lastFilterArg", lastFilterArg)
+            }
+        }
+        _cmdMap = arrayToCmdMap(filterCmd(arg));
+    }
+    listCmd();
+}
+
 function filterCmd(arg){
+    let cmds = []
     arg = trim(arg)
+    if (!arg) {
+        return cmds;
+    }
     let spaceName
     if (arg.indexOf('/') !== -1) {
         let index = arg.indexOf('/');
         spaceName = trim(arg.substring(0, index)) || $defaultSpace
         arg = trim(arg.substring(index + 1))
     }
-    let cmds = []
     for (let workspace of Object.values($workspaceMap)) {
         let spaceTmp = getSpaceFromDir(workspace);
         if (!spaceName || spaceName === spaceTmp) {
@@ -1366,7 +1536,7 @@ function filterCmd(arg){
 
 function _filterCmd(dirPath, arg) {
     let cmdMap = {}
-    let files = _fs.readdirSync(dirPath).filter(isJsirFileName)
+    let files = fs.readdirSync(dirPath).filter(isJsirFileName)
     for (let file of files) {
         file = trim(file)
         let uniqueName = toUniqueName(dirPath + '/' + file)
@@ -1457,7 +1627,7 @@ async function runCmd(str = '', uniqueName = '', text = '') {
         let strs = str.split(/\s+/)
         if (!uniqueName) {
             if (!_cmdMap[strs[0]] && strs[0] !== '0') {
-                warn('no items')
+                console.warn('no items')
                 return
             }
             if (_cmdMap[strs[0]]) {
@@ -1467,7 +1637,7 @@ async function runCmd(str = '', uniqueName = '', text = '') {
 
         if (uniqueName) {
             path = getFullPath(uniqueName);
-            text = String(_fs.readFileSync(path))
+            text = String(fs.readFileSync(path))
         } else {
             text = await getCbText()
         }
@@ -1488,7 +1658,7 @@ async function runCmd(str = '', uniqueName = '', text = '') {
 
 async function runScript(uniqueName, oriArgs) {
     let path = getFullPath(uniqueName);
-    let text = String(_fs.readFileSync(path))
+    let text = String(fs.readFileSync(path))
     let argDef = getArgDef(text)
     let scriptArgs = await getScriptArgs(argDef, oriArgs);
     process.argv = [process.argv[0], path, ...(scriptArgs.map(String))]
@@ -1510,7 +1680,7 @@ async function getScriptArgs(argDef, oriArgs) {
         }
         if (arg.startsWith(":") || arg.startsWith("_") && !arg.endsWith(' ')) {
             arg = arg.replace(/^:/, '')
-            if (oriArgs[i+1] && (oriArgs[i+1].endsWith(' ') || !(oriArgs[i+1].startsWith(":") || oriArgs[i+1].startsWith("_")))) {
+            if (oriArgs[i+1] && (oriArgs[i+1].endsWith(' ') || !(oriArgs[i+1].startsWith(":") || oriArgs[i+1].startsWith("_") || oriArgs[i+1].startsWith("-")))) {
                 pair = [arg, oriArgs[i+1]]
                 i++
             } else {
@@ -1560,7 +1730,7 @@ async function getScriptArgs(argDef, oriArgs) {
         }
         if (scriptArgKeys.indexOf(name) === -1 || (reg && !reg.test(scriptArgs[name]))) {
             argAbsent = true
-            warn(`require ${warnStr(name)}` + (defStr ? ` <${defStr}>`:''))
+            console.warn(`require ${warnStr(name)}` + (defStr ? ` <${defStr}>`:''))
         }
     }
     if (argAbsent) {
@@ -1600,11 +1770,39 @@ function enrichArgs(str) {
     return args
 }
 
-function getArgDef(text) {
-    let exeStr = trim(reget(text, /\$defArgs\(\s*(\{[\s\S]*?\})\s*\)/))
+function parseArgDef(inputString) {
+    let result = {}
+    let preStr = trim(reget(inputString, /\{([\s\S]*?)}\s*=\s*\$defArgs\s*\(/))
+    if (!preStr) {
+        return result;
+    }
+    let ss = preStr.split(/[,\n]|(?<!\/)\/(?=\/)/g).map(trim).filter(i => i);
+    for (let i = 0; i < ss.length; i++) {
+        let s1 = trim(ss[i]);
+        if (s1.startsWith("/")) {
+            continue;
+        }
+        if (ss[i+1] && ss[i+1].startsWith("/")) {
+            result[s1] = trim(ss[i+1].replace(/^\//, ""));
+            i++;
+        } else {
+            result[s1] = '';
+        }
+    }
+    return result;
+}
+
+function getArgDef(text, uniqueName) {
+    if (uniqueName && !parseUniqueName(uniqueName)[1].startsWith("e ")) {
+        return {}
+    }
+    if (text.indexOf("$defArgs") === -1) {
+        return {}
+    }
+    let exeStr = trim(reget(text, /\$defArgs\s*\(\s*(\{[\s\S]*?})\s*\)/))
     let argDef = {}
     try {
-        argDef = (exeStr ? evalVal(exeStr) : {}) || {}
+        argDef = (exeStr ? evalVal(exeStr) : parseArgDef(text)) || {}
         let array = []
         for (let key of Object.keys(argDef)) {
             if (/\s/.test(key) || array.hasOwnProperty(key)) {
@@ -1666,7 +1864,7 @@ function tipsOnRmCallback(key) {
                 callback()
             } catch (e) {
                 $log(errorStack(e))
-                error(`[${key}] OnRmCallback: ${String(e)}`)
+                console.error(`[${key}] OnRmCallback: ${String(e)}`)
             }
         }
     }
@@ -1676,6 +1874,10 @@ function getCmdMd5Key(str) {
     return '0x' + md5(str).substr(0, 8);
 }
 
+function isMd5Key(str) {
+    return /^0x[a-z\d]{8}$/.test(str);
+}
+
 function filterRequire(currSpace, cmdMatchStr) {
     if (typeof cmdMatchStr === 'number') {
         cmdMatchStr = '0x' + pad(8, BigNumber(cmdMatchStr).toString(16), '0');
@@ -1690,7 +1892,7 @@ function filterRequire(currSpace, cmdMatchStr) {
         uName = pr[0] + "/i " + pr[1]
         fullPath = getFullPath(uName)
     }
-    if (fullPath && _fs.existsSync(fullPath)) {
+    if (fullPath && fs.existsSync(fullPath)) {
         cmds = [uName]
     } else {
         let appointSpace = parseUniqueName(cmdMatchStr)[0]
@@ -1711,7 +1913,7 @@ async function _requireSource(currSpace, cmdMatchStr) {
     let result
     let uniqueName = filterRequire(currSpace, cmdMatchStr);
     let path = getFullPath(uniqueName)
-    let text = String(_fs.readFileSync(path))
+    let text = String(fs.readFileSync(path))
     let pair = parseUniqueName(uniqueName)
     if (pair[1].startsWith('i ')) {
         result = await evalText(text, uniqueName)
@@ -1725,27 +1927,31 @@ async function _requireSource(currSpace, cmdMatchStr) {
     if (!vl(result)) {
         throw `invalid result: ${cmdMatchStr}`
     }
-    if (getType(result) === 'Function' || getType(result) === 'AsyncFunction') {
-        let tmp = result;
-        result = (...args) => {
-            let resp
-            try {
-                resp = tmp(...args)
-                if (getType(resp) === 'Promise') {
-                    return resp.then(result => {
-                        return Promise.resolve(result);
-                    }).catch(e => {
-                        return Promise.reject(errorTag(e, uniqueName))
-                    })
-                } else {
-                    return resp;
-                }
-            } catch (e) {
-                throw errorTag(e, uniqueName);
-            }
+    return result
+}
+
+function addErrorTag(text) {
+    let result = [];
+    let lines = text.split(/\n/);
+    let functionEnd = true;
+    let fnName = '';
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        result.push(line);
+        if (line.startsWith('async function') || line.startsWith('function')) {
+            fnName = reget(line, /function\s+([\s\S]+)\s*\(/)
+        }
+        if (functionEnd && fnName && (/\)\s*\{$/.test(trim(line)) || (line.startsWith("{") && trim(line) === '{'))) {
+            result[i] += 'try{';
+            functionEnd = false;
+        }
+        if (line.startsWith("}") && !functionEnd) {
+            result[i] = `}catch(e){throw($errorTag(e,$cmdName+'[${fnName}]'))}` + line;
+            functionEnd = true;
+            fnName = '';
         }
     }
-    return result
+    return result.join('\n');
 }
 
 async function evalText($text = '', $cmdName = '', $args = []) {
@@ -1766,30 +1972,26 @@ async function evalText($text = '', $cmdName = '', $args = []) {
     let $require = async (matchItem) => {
         return await _requireSource(currSpace, matchItem)
     }
-    try {
-        return await evalCode($text, $cmdName, $args,
-            $data, $config,
-            $require, $requires,
-            nextLine, nextText,
-            setTips, delTips,
-            wrapperInput, filterCmd,
-            currSpace,
-            $homeDir, $lib)
-    } catch(e) {
-        throw errorTag(e, $cmdName);
-    }
+    return await evalCode(addErrorTag($text), $cmdName, $args,
+        $data, $config,
+        $require, $requires,
+        nextLine, nextText,
+        setTips, delTips,
+        wrapperInput, filterCmd,
+        currSpace,
+        $homeDir, $lib, _cmdMap);
 }
 
 process.on('uncaughtException',function(err){
-    error(err, 'uncaughtException', )
+    console.error('uncaughtException', err)
     _noAppendNextLine || nextLine()
 })
 process.on('unhandledRejection',function(err){
-    error(err, 'unhandledRejection')
+    console.error('unhandledRejection', err)
     _noAppendNextLine || nextLine()
 })
 process.on('rejectionHandled',function(err){
-    error(err, 'rejectionHandled')
+    console.error('rejectionHandled', err)
     _noAppendNextLine || nextLine()
 })
 process.on('SIGINT', function () {