monowalk 1.1.0

package/.gitignore

@@ -0,0 +1,40 @@
+# dependencies (bun install)
+node_modules
+
+# output
+out
+dist
+*.tgz
+
+# code coverage
+coverage
+*.lcov
+
+# logs
+logs
+_.log
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+
+# IntelliJ based IDEs
+.idea
+
+# Finder (MacOS) folder config
+.DS_Store
+
+.npmrc
+
+manager.txt
+
+bin

package/.npmignore

@@ -0,0 +1,40 @@
+# dependencies (bun install)
+node_modules
+
+# output
+out
+dist
+*.tgz
+
+# code coverage
+coverage
+*.lcov
+
+# logs
+logs
+_.log
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+
+# IntelliJ based IDEs
+.idea
+
+# Finder (MacOS) folder config
+.DS_Store
+
+*.ts
+
+.npmrc
+
+manager.txt

package/README.md

@@ -0,0 +1,38 @@
+# Monowalk
+
+A monorepo-first tool (cli) to easily manage different related projects in a single repository.
+(not 100% tested yet, use at your own risk)
+
+## Installation
+
+You can install Monowalk globally using npm:
+
+```bash
+npm install -g monowalk
+```
+
+## Features
+
+- **Switch Between Projects**: Seamlessly switch between different projects within the monorepo.
+- **Unified Commands**: Run commands across all projects or specific ones with ease.
+- **Dependency Management**: Handle shared dependencies efficiently.
+- **Project Scaffolding**: Quickly create new projects with predefined templates.
+- **Version Control Integration**: Built-in support for Git to manage changes across projects.
+- **Customizable Workflows**: Define custom workflows for building, testing, and deploying projects.
+- **Extensible Plugins**: Support for plugins to extend functionality as needed.
+- **Comprehensive Documentation**: Detailed guides and API references to help you get started and make the most of Monowalk.
+
+## How
+
+- Monowalk tries to not overload your workspace by being able to switch between projects, only loading the necessary folder for the current project, without having a Visual Studio Code extension.
+
+## Attention
+
+Some features are not yet implemented. Stay tuned for updates! It includes:
+
+- Dependency Management
+- Version Control Integration
+- Extensible Plugins
+- Comprehensive Documentation
+- Customizable Workflows
+- Unified Commands

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("./index");

package/bin/commands/help.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.description = void 0;
+exports.default = help;
+const getCommands_1 = require("../utils/getCommands");
+const multiline_1 = require("../utils/multiline");
+const package_1 = require("../utils/package");
+function help() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let commands = yield (0, getCommands_1.getCommands)();
+        let name = (0, package_1.getPackageInfo)().name;
+        (0, multiline_1.multilinelog) `Usage: ${name} [command] [options]`;
+        (0, multiline_1.multilinelog) `
+Commands:`;
+        for (let cmd of commands) {
+            (0, multiline_1.multilinelog) `   ${cmd.name}         ${cmd.description}`;
+        }
+        (0, multiline_1.multilinelog) `
+  
+For more information on a specific command, run:
+   ${name} [command] --help
+`;
+    });
+}
+exports.description = "Display help information about commands";

package/bin/commands/init.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.description = void 0;
+exports.default = init;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cwd = process.cwd();
+function init() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Initializing a new monorepo project with Monowalk...");
+        // Create a .monowalkrc configuration file
+        const configPath = path_1.default.join(cwd, ".monowalkrc");
+        if (fs_1.default.existsSync(configPath)) {
+            console.log(".monowalkrc already exists. Initialization skipped.");
+            return;
+        }
+        let defaultConfig = {
+            projects: {}, // {"project-name": "path/to/project"},
+            shared_dependencies: {}, // {"dependency-name": {projects: ["project1", "project2"], version: "1.0.0"}},
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+        console.log("Created .monowalkrc configuration file.");
+    });
+}
+exports.description = "Initialize a monorepo project with Monowalk.";

package/bin/commands/new.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.description = void 0;
+exports.default = newCommand;
+const input_1 = __importDefault(require("@inquirer/input"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../utils/config");
+const cwd = process.cwd();
+function newCommand(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ installCommand, allInstallCommand, manager, }) {
+        let name = yield (0, input_1.default)({
+            message: "Project name:",
+            validate(value) {
+                if (value.length === 0) {
+                    return "Project name cannot be empty.";
+                }
+                if (/\s/.test(value)) {
+                    return "Project name cannot contain spaces.";
+                }
+                // no caps
+                if (value !== value.toLowerCase()) {
+                    return "Project name must be lowercase.";
+                }
+                return true;
+            },
+            theme: {
+                prefix: "➕ ",
+                spinner: {
+                    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+                    interval: 80,
+                },
+            },
+        });
+        console.log(`Creating project: ${name}`);
+        // Create project directory
+        const projectPath = path_1.default.join(cwd, name);
+        if ((0, fs_1.existsSync)(projectPath)) {
+            console.log(`Project directory "${name}" already exists. Creation skipped.`);
+            return;
+        }
+        const { content, configPath } = (0, config_1.findNearestConfigPath)();
+        content.projects[name] = name;
+        // Save the updated configuration file
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(content, null, 2));
+        (0, fs_1.mkdirSync)(projectPath);
+        // Initialize the package.json file
+        (0, child_process_1.execSync)(`${allInstallCommand}`, { cwd: projectPath, stdio: "inherit" });
+    });
+}
+exports.description = "Create a project inside the Monowalk monorepo.";

package/bin/commands/out.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.description = void 0;
+exports.default = out;
+const fs_1 = require("fs");
+const config_1 = require("../utils/config");
+const esbuild = __importStar(require("esbuild"));
+const path_1 = __importDefault(require("path"));
+function out(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ args }) {
+        // Build a project in a single js file
+        console.log("Building project into a single JS file...");
+        // Implementation goes here
+        if (!args || args.length === 0) {
+            console.log("No project name specified.");
+            return;
+        }
+        let data = (0, config_1.findNearestConfigPath)();
+        if (!data.projects) {
+            console.log("No projects defined in the configuration file.");
+            return;
+        }
+        const projectName = args[0];
+        if (!data.projects.includes(projectName)) {
+            console.log(`Project "${projectName}" not found in the configuration file.`);
+            return;
+        }
+        const entryFolder = data.projects[projectName];
+        // Get entry file from the package.json of the project
+        const packageJsonPath = path_1.default.join(entryFolder, "package.json");
+        const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+        const entryFile = packageJson.main || "index.js";
+        const entryFilePath = path_1.default.join(entryFolder, entryFile);
+        yield esbuild.build({
+            entryPoints: [entryFilePath],
+            bundle: true,
+            outfile: path_1.default.join(entryFolder, "monowalk", `${projectName}.js`),
+        });
+    });
+}
+exports.description = "Build targer project into a single JavaScript file";

package/bin/commands/to.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.description = void 0;
+exports.default = to;
+function to() { }
+exports.description = "Load a project in visual studio code";

package/bin/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const process_1 = require("process");
+const help_1 = __importDefault(require("./commands/help"));
+const getCommands_1 = require("./utils/getCommands");
+const fs_1 = require("fs");
+const input_1 = __importDefault(require("@inquirer/input"));
+const path_1 = __importDefault(require("path"));
+let installCommand = "";
+let allInstallCommand = "";
+let packageManager = "";
+function askAndSavePackageManager() {
+    return __awaiter(this, void 0, void 0, function* () {
+        packageManager = yield (0, input_1.default)({
+            message: "Enter your package manager (npm, yarn, pnpm, bun): ",
+        });
+        (0, fs_1.writeFileSync)(path_1.default.join(__dirname, "manager.txt"), packageManager.trim());
+    });
+}
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        packageManager = (0, fs_1.readFileSync)(path_1.default.join(__dirname, "manager.txt"), "utf-8");
+        if (packageManager.trim() === "")
+            yield askAndSavePackageManager();
+    }
+    catch (_a) {
+        (0, fs_1.writeFileSync)(path_1.default.join(__dirname, "manager.txt"), "");
+        yield askAndSavePackageManager();
+    }
+    switch (packageManager) {
+        case "npm":
+            installCommand = "npm i";
+            allInstallCommand = "npm install";
+            break;
+        case "yarn":
+            installCommand = "yarn add";
+            allInstallCommand = "yarn install";
+            break;
+        case "pnpm":
+            installCommand = "pnpm add";
+            allInstallCommand = "pnpm install";
+            break;
+        case "bun":
+            installCommand = "bun add";
+            allInstallCommand = "bun install";
+            break;
+        default:
+            console.log(`Unsupported package manager: ${packageManager}. Supported managers are npm, yarn, pnpm, and bun.`);
+            process.exit(1);
+    }
+    let _isLocalRun = false;
+    for (let arg of process_1.argv) {
+        if (arg.includes("bun") ||
+            arg.includes("ts-node") ||
+            arg.includes("tsx") ||
+            arg.includes("node")) {
+            _isLocalRun = true;
+        }
+    }
+    const args = _isLocalRun ? process_1.argv.slice(2) : process_1.argv.slice(1);
+    const commands = yield (0, getCommands_1.getCommands)();
+    if (args.length === 0) {
+        yield (0, help_1.default)();
+    }
+    else {
+        const commandName = args[0];
+        const command = commands.find((cmd) => cmd.name === commandName);
+        if (command) {
+            yield command.exec({
+                installCommand,
+                allInstallCommand,
+                manager: packageManager.trim(),
+                args: args.slice(1),
+            });
+        }
+        else {
+            console.log(`Unknown command: ${commandName}`);
+            console.log(`Use the help command to see the list of available commands.`);
+        }
+    }
+}))();

package/bin/utils/config.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNearestConfigPath = findNearestConfigPath;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+let monowalkConfigFilenames = [".monowalkrc"];
+function findNearestConfigPath(iterations = 3) {
+    let workingDir = process.cwd();
+    let iters = 1;
+    let goBack = "..";
+    let found = false;
+    let configPath = null;
+    function configExists(dir) {
+        let exists = false;
+        if (iters > iterations)
+            return null;
+        iters++;
+        for (let filename of monowalkConfigFilenames) {
+            let fullPath = path_1.default.join(dir, filename);
+            if (fs_1.default.existsSync(fullPath)) {
+                configPath = fullPath;
+                exists = true;
+                break;
+            }
+        }
+        if (!exists)
+            return configExists(path_1.default.join(dir, goBack));
+        found = true;
+        return configPath;
+    }
+    configPath = configExists(workingDir);
+    if (!found || !configPath) {
+        throw new Error("No monowalk.config.js found in any parent directory.");
+    }
+    let content = JSON.parse(fs_1.default.readFileSync(configPath, "utf-8"));
+    return { content, configPath };
+}

package/bin/utils/folder.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFolder = loadFolder;
+const child_process_1 = require("child_process");
+const protocol = "vscode://";
+function loadFolder(folderPath) {
+    (0, child_process_1.spawnSync)(`open ${protocol}file/${folderPath}`);
+}

package/bin/utils/getCommands.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommands = getCommands;
+const fs_1 = require("fs");
+const win32_1 = __importDefault(require("path/win32"));
+let files = (0, fs_1.readdirSync)(win32_1.default.join(__dirname, "..", "commands")).filter((file) => file.endsWith(".ts"));
+function getCommands() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let commands = [];
+        for (let file of files) {
+            let { default: command, description } = yield Promise.resolve(`${win32_1.default.join(__dirname, "..", "commands", file)}`).then(s => __importStar(require(s)));
+            commands.push({
+                exec: command,
+                description: description,
+                name: file.replace(".ts", ""),
+            });
+        }
+        return commands;
+    });
+}

package/bin/utils/multiline.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multilinelog = multilinelog;
+function multilinelog(strings, ...values) {
+    let output = "";
+    strings.forEach((str, i) => {
+        output += str;
+        if (i < values.length) {
+            output += values[i];
+        }
+    });
+    console.log(output);
+}

package/bin/utils/package.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageInfo = getPackageInfo;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function getPackageInfo() {
+    const packagePath = path_1.default.join(__dirname, "..", "..", "package.json");
+    const packageData = fs_1.default.readFileSync(packagePath, "utf-8");
+    return JSON.parse(packageData);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "dependencies": {
+    "@inquirer/input": "^5.0.4",
+    "esbuild": "^0.27.2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.8",
+    "typescript": "^5.9.3"
+  },
+  "name": "monowalk",
+  "type": "commonjs",
+  "module": "bin/cli.js",
+  "bin": {
+    "monowalk": "bin/cli.js",
+    "mw": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    ".npmignore",
+    ".gitignore",
+    "README.md",
+    "package.json"
+  ],
+  "main": "bin/cli.js",
+  "repository": {
+    "type": "github",
+    "url": "git+https://github.com/nekoniyah/monowalk.git"
+  },
+  "private": false,
+  "version": "1.1.0",
+  "scripts": {
+    "prepublish": "tsc"
+  }
+}