2819be51d3
- Fix Zod schema conversion, update headers, add premium telemetry display, improve user auth flow, and standardize email fields Functionally complete on this end, mostly polish around user experience and need to add in profile, upgrade/downgrade, etc. But the AI commands are working off the gateway.
1286 lines
39 KiB
JavaScript
Executable File
1286 lines
39 KiB
JavaScript
Executable File
/**
|
||
* Task Master
|
||
* Copyright (c) 2025 Eyal Toledano, Ralph Khreish
|
||
*
|
||
* This software is licensed under the MIT License with Commons Clause.
|
||
* You may use this software for any purpose, including commercial applications,
|
||
* and modify and redistribute it freely, subject to the following restrictions:
|
||
*
|
||
* 1. You may not sell this software or offer it as a service.
|
||
* 2. The origin of this software must not be misrepresented.
|
||
* 3. Altered source versions must be plainly marked as such.
|
||
*
|
||
* For the full license text, see the LICENSE file in the root directory.
|
||
*/
|
||
|
||
import fs from "fs";
|
||
import path from "path";
|
||
import readline from "readline";
|
||
import { fileURLToPath } from "url";
|
||
import { dirname } from "path";
|
||
import chalk from "chalk";
|
||
import figlet from "figlet";
|
||
import boxen from "boxen";
|
||
import gradient from "gradient-string";
|
||
import inquirer from "inquirer";
|
||
import open from "open";
|
||
import express from "express";
|
||
import { isSilentMode } from "./modules/utils.js";
|
||
import { convertAllCursorRulesToRooRules } from "./modules/rule-transformer.js";
|
||
import { execSync } from "child_process";
|
||
import {
|
||
initializeUser,
|
||
registerUserWithGateway,
|
||
} from "./modules/user-management.js";
|
||
|
||
const __filename = fileURLToPath(import.meta.url);
|
||
const __dirname = dirname(__filename);
|
||
|
||
// Define log levels
|
||
const LOG_LEVELS = {
|
||
debug: 0,
|
||
info: 1,
|
||
warn: 2,
|
||
error: 3,
|
||
success: 4,
|
||
};
|
||
|
||
// Determine log level from environment variable or default to 'info'
|
||
const LOG_LEVEL = process.env.TASKMASTER_LOG_LEVEL
|
||
? LOG_LEVELS[process.env.TASKMASTER_LOG_LEVEL.toLowerCase()]
|
||
: LOG_LEVELS.info; // Default to info
|
||
|
||
// Create a color gradient for the banner
|
||
const coolGradient = gradient(["#00b4d8", "#0077b6", "#03045e"]);
|
||
const warmGradient = gradient(["#fb8b24", "#e36414", "#9a031e"]);
|
||
|
||
// Display a fancy banner
|
||
function displayBanner() {
|
||
if (isSilentMode()) return;
|
||
|
||
console.clear();
|
||
const bannerText = figlet.textSync("Task Master AI", {
|
||
font: "Standard",
|
||
horizontalLayout: "default",
|
||
verticalLayout: "default",
|
||
});
|
||
|
||
console.log(coolGradient(bannerText));
|
||
|
||
// Add creator credit line below the banner
|
||
console.log(
|
||
chalk.dim("by ") + chalk.cyan.underline("https://x.com/eyaltoledano")
|
||
);
|
||
|
||
console.log(
|
||
boxen(chalk.white(`${chalk.bold("Initializing")} your new project`), {
|
||
padding: 1,
|
||
margin: { top: 0, bottom: 1 },
|
||
borderStyle: "round",
|
||
borderColor: "cyan",
|
||
})
|
||
);
|
||
}
|
||
|
||
// Logging function with icons and colors
|
||
function log(level, ...args) {
|
||
const icons = {
|
||
debug: chalk.gray("🔍"),
|
||
info: chalk.blue("ℹ️"),
|
||
warn: chalk.yellow("⚠️"),
|
||
error: chalk.red("❌"),
|
||
success: chalk.green("✅"),
|
||
};
|
||
|
||
if (LOG_LEVELS[level] >= LOG_LEVEL) {
|
||
const icon = icons[level] || "";
|
||
|
||
// Only output to console if not in silent mode
|
||
if (!isSilentMode()) {
|
||
if (level === "error") {
|
||
console.error(icon, chalk.red(...args));
|
||
} else if (level === "warn") {
|
||
console.warn(icon, chalk.yellow(...args));
|
||
} else if (level === "success") {
|
||
console.log(icon, chalk.green(...args));
|
||
} else if (level === "info") {
|
||
console.log(icon, chalk.blue(...args));
|
||
} else {
|
||
console.log(icon, ...args);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Write to debug log if DEBUG=true
|
||
if (process.env.DEBUG === "true") {
|
||
const logMessage = `[${level.toUpperCase()}] ${args.join(" ")}\n`;
|
||
fs.appendFileSync("init-debug.log", logMessage);
|
||
}
|
||
}
|
||
|
||
// Function to create directory if it doesn't exist
|
||
function ensureDirectoryExists(dirPath) {
|
||
if (!fs.existsSync(dirPath)) {
|
||
fs.mkdirSync(dirPath, { recursive: true });
|
||
log("info", `Created directory: ${dirPath}`);
|
||
}
|
||
}
|
||
|
||
// Function to add shell aliases to the user's shell configuration
|
||
function addShellAliases() {
|
||
const homeDir = process.env.HOME || process.env.USERPROFILE;
|
||
let shellConfigFile;
|
||
|
||
// Determine which shell config file to use
|
||
if (process.env.SHELL?.includes("zsh")) {
|
||
shellConfigFile = path.join(homeDir, ".zshrc");
|
||
} else if (process.env.SHELL?.includes("bash")) {
|
||
shellConfigFile = path.join(homeDir, ".bashrc");
|
||
} else {
|
||
log("warn", "Could not determine shell type. Aliases not added.");
|
||
return false;
|
||
}
|
||
|
||
try {
|
||
// Check if file exists
|
||
if (!fs.existsSync(shellConfigFile)) {
|
||
log(
|
||
"warn",
|
||
`Shell config file ${shellConfigFile} not found. Aliases not added.`
|
||
);
|
||
return false;
|
||
}
|
||
|
||
// Check if aliases already exist
|
||
const configContent = fs.readFileSync(shellConfigFile, "utf8");
|
||
if (configContent.includes("alias tm='task-master'")) {
|
||
log("info", "Task Master aliases already exist in shell config.");
|
||
return true;
|
||
}
|
||
|
||
// Add aliases to the shell config file
|
||
const aliasBlock = `
|
||
# Task Master aliases added on ${new Date().toLocaleDateString()}
|
||
alias tm='task-master'
|
||
alias taskmaster='task-master'
|
||
`;
|
||
|
||
fs.appendFileSync(shellConfigFile, aliasBlock);
|
||
log("success", `Added Task Master aliases to ${shellConfigFile}`);
|
||
log(
|
||
"info",
|
||
"To use the aliases in your current terminal, run: source " +
|
||
shellConfigFile
|
||
);
|
||
|
||
return true;
|
||
} catch (error) {
|
||
log("error", `Failed to add aliases: ${error.message}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Function to copy a file from the package to the target directory
|
||
function copyTemplateFile(templateName, targetPath, replacements = {}) {
|
||
// Get the file content from the appropriate source directory
|
||
let sourcePath;
|
||
|
||
// Map template names to their actual source paths
|
||
switch (templateName) {
|
||
// case 'scripts_README.md':
|
||
// sourcePath = path.join(__dirname, '..', 'assets', 'scripts_README.md');
|
||
// break;
|
||
case "dev_workflow.mdc":
|
||
sourcePath = path.join(
|
||
__dirname,
|
||
"..",
|
||
".cursor",
|
||
"rules",
|
||
"dev_workflow.mdc"
|
||
);
|
||
break;
|
||
case "taskmaster.mdc":
|
||
sourcePath = path.join(
|
||
__dirname,
|
||
"..",
|
||
".cursor",
|
||
"rules",
|
||
"taskmaster.mdc"
|
||
);
|
||
break;
|
||
case "cursor_rules.mdc":
|
||
sourcePath = path.join(
|
||
__dirname,
|
||
"..",
|
||
".cursor",
|
||
"rules",
|
||
"cursor_rules.mdc"
|
||
);
|
||
break;
|
||
case "self_improve.mdc":
|
||
sourcePath = path.join(
|
||
__dirname,
|
||
"..",
|
||
".cursor",
|
||
"rules",
|
||
"self_improve.mdc"
|
||
);
|
||
break;
|
||
// case 'README-task-master.md':
|
||
// sourcePath = path.join(__dirname, '..', 'README-task-master.md');
|
||
break;
|
||
case "windsurfrules":
|
||
sourcePath = path.join(__dirname, "..", "assets", ".windsurfrules");
|
||
break;
|
||
case ".roomodes":
|
||
sourcePath = path.join(__dirname, "..", "assets", "roocode", ".roomodes");
|
||
break;
|
||
case "architect-rules":
|
||
case "ask-rules":
|
||
case "boomerang-rules":
|
||
case "code-rules":
|
||
case "debug-rules":
|
||
case "test-rules":
|
||
// Extract the mode name from the template name (e.g., 'architect' from 'architect-rules')
|
||
const mode = templateName.split("-")[0];
|
||
sourcePath = path.join(
|
||
__dirname,
|
||
"..",
|
||
"assets",
|
||
"roocode",
|
||
".roo",
|
||
`rules-${mode}`,
|
||
templateName
|
||
);
|
||
break;
|
||
default:
|
||
// For other files like env.example, gitignore, etc. that don't have direct equivalents
|
||
sourcePath = path.join(__dirname, "..", "assets", templateName);
|
||
}
|
||
|
||
// Check if the source file exists
|
||
if (!fs.existsSync(sourcePath)) {
|
||
// Fall back to templates directory for files that might not have been moved yet
|
||
sourcePath = path.join(__dirname, "..", "assets", templateName);
|
||
if (!fs.existsSync(sourcePath)) {
|
||
log("error", `Source file not found: ${sourcePath}`);
|
||
return;
|
||
}
|
||
}
|
||
|
||
let content = fs.readFileSync(sourcePath, "utf8");
|
||
|
||
// Replace placeholders with actual values
|
||
Object.entries(replacements).forEach(([key, value]) => {
|
||
const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
|
||
content = content.replace(regex, value);
|
||
});
|
||
|
||
// Handle special files that should be merged instead of overwritten
|
||
if (fs.existsSync(targetPath)) {
|
||
const filename = path.basename(targetPath);
|
||
|
||
// Handle .gitignore - append lines that don't exist
|
||
if (filename === ".gitignore") {
|
||
log("info", `${targetPath} already exists, merging content...`);
|
||
const existingContent = fs.readFileSync(targetPath, "utf8");
|
||
const existingLines = new Set(
|
||
existingContent.split("\n").map((line) => line.trim())
|
||
);
|
||
const newLines = content
|
||
.split("\n")
|
||
.filter((line) => !existingLines.has(line.trim()));
|
||
|
||
if (newLines.length > 0) {
|
||
// Add a comment to separate the original content from our additions
|
||
const updatedContent =
|
||
existingContent.trim() +
|
||
"\n\n# Added by Claude Task Master\n" +
|
||
newLines.join("\n");
|
||
fs.writeFileSync(targetPath, updatedContent);
|
||
log("success", `Updated ${targetPath} with additional entries`);
|
||
} else {
|
||
log("info", `No new content to add to ${targetPath}`);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// Handle .windsurfrules - append the entire content
|
||
if (filename === ".windsurfrules") {
|
||
log(
|
||
"info",
|
||
`${targetPath} already exists, appending content instead of overwriting...`
|
||
);
|
||
const existingContent = fs.readFileSync(targetPath, "utf8");
|
||
|
||
// Add a separator comment before appending our content
|
||
const updatedContent =
|
||
existingContent.trim() +
|
||
"\n\n# Added by Task Master - Development Workflow Rules\n\n" +
|
||
content;
|
||
fs.writeFileSync(targetPath, updatedContent);
|
||
log("success", `Updated ${targetPath} with additional rules`);
|
||
return;
|
||
}
|
||
|
||
// Handle README.md - offer to preserve or create a different file
|
||
if (filename === "README-task-master.md") {
|
||
log("info", `${targetPath} already exists`);
|
||
// Create a separate README file specifically for this project
|
||
const taskMasterReadmePath = path.join(
|
||
path.dirname(targetPath),
|
||
"README-task-master.md"
|
||
);
|
||
fs.writeFileSync(taskMasterReadmePath, content);
|
||
log(
|
||
"success",
|
||
`Created ${taskMasterReadmePath} (preserved original README-task-master.md)`
|
||
);
|
||
return;
|
||
}
|
||
|
||
// For other files, warn and prompt before overwriting
|
||
log("warn", `${targetPath} already exists, skipping.`);
|
||
return;
|
||
}
|
||
|
||
// If the file doesn't exist, create it normally
|
||
fs.writeFileSync(targetPath, content);
|
||
log("info", `Created file: ${targetPath}`);
|
||
}
|
||
|
||
// Main function to initialize a new project (No longer needs isInteractive logic)
|
||
async function initializeProject(options = {}) {
|
||
// Receives options as argument
|
||
// Only display banner if not in silent mode
|
||
if (!isSilentMode()) {
|
||
displayBanner();
|
||
}
|
||
|
||
const skipPrompts = options.yes || (options.name && options.description);
|
||
|
||
if (skipPrompts) {
|
||
if (!isSilentMode()) {
|
||
console.log("SKIPPING PROMPTS - Using defaults or provided values");
|
||
}
|
||
|
||
// Use provided options or defaults
|
||
const projectName = options.name || "task-master-project";
|
||
const projectDescription =
|
||
options.description || "A project managed with Task Master AI";
|
||
const projectVersion = options.version || "0.1.0";
|
||
const authorName = options.author || "Vibe coder";
|
||
const dryRun = options.dryRun || false;
|
||
const addAliases = options.aliases || false;
|
||
|
||
if (dryRun) {
|
||
log("info", "DRY RUN MODE: No files will be modified");
|
||
log("info", "Would initialize Task Master project");
|
||
log("info", "Would create/update necessary project files");
|
||
if (addAliases) {
|
||
log("info", "Would add shell aliases for task-master");
|
||
}
|
||
return {
|
||
dryRun: true,
|
||
};
|
||
}
|
||
|
||
// NON-INTERACTIVE MODE - Try auth/init gracefully
|
||
let userSetupResult = null;
|
||
let isGatewayAvailable = false;
|
||
|
||
// Try to initialize user, but don't throw errors if it fails
|
||
try {
|
||
userSetupResult = await initializeUser(process.cwd());
|
||
if (userSetupResult.success) {
|
||
isGatewayAvailable = true;
|
||
if (!isSilentMode()) {
|
||
log("info", "Gateway connection successful");
|
||
}
|
||
} else {
|
||
if (!isSilentMode()) {
|
||
log("info", "Gateway not available, using BYOK mode");
|
||
}
|
||
isGatewayAvailable = false;
|
||
}
|
||
} catch (error) {
|
||
// Silent failure - gateway not available
|
||
if (!isSilentMode()) {
|
||
log("info", "Gateway not available, using BYOK mode");
|
||
}
|
||
isGatewayAvailable = false;
|
||
userSetupResult = null;
|
||
}
|
||
|
||
// Create project structure - always use BYOK for non-interactive mode
|
||
// since we don't want to prompt for mode selection
|
||
createProjectStructure(
|
||
addAliases,
|
||
dryRun,
|
||
userSetupResult, // Pass the auth result (may be null)
|
||
"byok", // Always use BYOK for non-interactive
|
||
null,
|
||
userSetupResult?.userId || null
|
||
);
|
||
} else {
|
||
// Interactive logic - NEW FLOW STARTS HERE
|
||
log("info", "Setting up your Task Master project...");
|
||
const rl = readline.createInterface({
|
||
input: process.stdin,
|
||
output: process.stdout,
|
||
});
|
||
|
||
try {
|
||
// STEP 1: Welcome message
|
||
console.log(
|
||
boxen(
|
||
chalk.blue.bold("🚀 Welcome to Taskmaster AI") +
|
||
"\n\n" +
|
||
chalk.white("Setting up your project workspace..."),
|
||
{
|
||
padding: 1,
|
||
margin: { top: 1, bottom: 1 },
|
||
borderStyle: "round",
|
||
borderColor: "blue",
|
||
}
|
||
)
|
||
);
|
||
|
||
// STEP 2: Try auth/init gracefully to detect gateway availability
|
||
let userSetupResult = null;
|
||
let isGatewayAvailable = false;
|
||
|
||
try {
|
||
userSetupResult = await initializeUser(process.cwd());
|
||
if (userSetupResult.success) {
|
||
isGatewayAvailable = true;
|
||
console.log(
|
||
boxen(
|
||
chalk.green("✅ Gateway Connection Successful") +
|
||
"\n\n" +
|
||
chalk.white("TaskMaster AI Gateway is available.") +
|
||
"\n" +
|
||
chalk.white("You can choose between BYOK or Hosted mode."),
|
||
{
|
||
padding: 1,
|
||
margin: { top: 1, bottom: 1 },
|
||
borderStyle: "round",
|
||
borderColor: "green",
|
||
}
|
||
)
|
||
);
|
||
} else {
|
||
// Silent failure - gateway not available
|
||
isGatewayAvailable = false;
|
||
}
|
||
} catch (error) {
|
||
// Silent failure - gateway not available
|
||
isGatewayAvailable = false;
|
||
userSetupResult = null;
|
||
}
|
||
|
||
// STEP 3: Choose AI access method (conditional based on gateway availability)
|
||
let selectedMode = "byok"; // Default to BYOK
|
||
let selectedPlan = null;
|
||
|
||
if (isGatewayAvailable) {
|
||
// Gateway is available, show both options
|
||
const modeResponse = await inquirer.prompt([
|
||
{
|
||
type: "list",
|
||
name: "accessMode",
|
||
message: "Choose Your AI Access Method:",
|
||
choices: [
|
||
{
|
||
name: "🔑 BYOK - Bring Your Own API Keys (You manage API keys & billing)",
|
||
value: "byok",
|
||
},
|
||
{
|
||
name: "🎯 Hosted API Gateway - All models, no keys needed (Recommended)",
|
||
value: "hosted",
|
||
},
|
||
],
|
||
default: "hosted",
|
||
},
|
||
]);
|
||
selectedMode = modeResponse.accessMode;
|
||
|
||
console.log(
|
||
boxen(
|
||
selectedMode === "byok"
|
||
? chalk.blue.bold("🔑 BYOK Mode Selected") +
|
||
"\n\n" +
|
||
chalk.white("You'll manage your own API keys and billing.") +
|
||
"\n" +
|
||
chalk.white("After setup, add your API keys to ") +
|
||
chalk.cyan(".env") +
|
||
chalk.white(" file.")
|
||
: chalk.green.bold("🎯 Hosted API Gateway Selected") +
|
||
"\n\n" +
|
||
chalk.white(
|
||
"All AI models available instantly - no API keys needed!"
|
||
) +
|
||
"\n" +
|
||
chalk.dim("Let's set up your subscription plan..."),
|
||
{
|
||
padding: 1,
|
||
margin: { top: 1, bottom: 1 },
|
||
borderStyle: "round",
|
||
borderColor: selectedMode === "byok" ? "blue" : "green",
|
||
}
|
||
)
|
||
);
|
||
|
||
// If hosted mode selected, handle subscription plan
|
||
if (selectedMode === "hosted") {
|
||
selectedPlan = await handleHostedSubscription();
|
||
}
|
||
} else {
|
||
// Gateway not available, silently proceed with BYOK mode
|
||
// Show standard BYOK mode message without mentioning gateway failure
|
||
console.log(
|
||
boxen(
|
||
chalk.blue.bold("🔑 BYOK Mode") +
|
||
"\n\n" +
|
||
chalk.white("You'll manage your own API keys and billing.") +
|
||
"\n" +
|
||
chalk.white("After setup, add your API keys to ") +
|
||
chalk.cyan(".env") +
|
||
chalk.white(" file."),
|
||
{
|
||
padding: 1,
|
||
margin: { top: 1, bottom: 1 },
|
||
borderStyle: "round",
|
||
borderColor: "blue",
|
||
}
|
||
)
|
||
);
|
||
selectedMode = "byok";
|
||
}
|
||
|
||
// STEP 4: Continue with aliases
|
||
const aliasResponse = await inquirer.prompt([
|
||
{
|
||
type: "confirm",
|
||
name: "addAliases",
|
||
message: "Add shell aliases (tm, taskmaster) for easier access?",
|
||
default: true,
|
||
},
|
||
]);
|
||
|
||
const addAliases = aliasResponse.addAliases;
|
||
const dryRun = options.dryRun || false;
|
||
|
||
// STEP 5: Show overview and continue with project creation
|
||
rl.close();
|
||
createProjectStructure(
|
||
addAliases,
|
||
dryRun,
|
||
userSetupResult,
|
||
selectedMode,
|
||
selectedPlan,
|
||
userSetupResult?.userId || null
|
||
);
|
||
} catch (error) {
|
||
rl.close();
|
||
log("error", `Error during initialization process: ${error.message}`);
|
||
process.exit(1);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Helper function to promisify readline question
|
||
function promptQuestion(rl, question) {
|
||
return new Promise((resolve) => {
|
||
rl.question(question, (answer) => {
|
||
resolve(answer);
|
||
});
|
||
});
|
||
}
|
||
|
||
// Function to create the project structure
|
||
function createProjectStructure(
|
||
addAliases,
|
||
dryRun,
|
||
gatewayRegistration,
|
||
selectedMode = "byok",
|
||
selectedPlan = null,
|
||
userId = null
|
||
) {
|
||
const targetDir = process.cwd();
|
||
log("info", `Initializing project in ${targetDir}`);
|
||
|
||
// Create directories
|
||
ensureDirectoryExists(path.join(targetDir, ".cursor", "rules"));
|
||
|
||
// Create Roo directories
|
||
ensureDirectoryExists(path.join(targetDir, ".roo"));
|
||
ensureDirectoryExists(path.join(targetDir, ".roo", "rules"));
|
||
for (const mode of [
|
||
"architect",
|
||
"ask",
|
||
"boomerang",
|
||
"code",
|
||
"debug",
|
||
"test",
|
||
]) {
|
||
ensureDirectoryExists(path.join(targetDir, ".roo", `rules-${mode}`));
|
||
}
|
||
|
||
ensureDirectoryExists(path.join(targetDir, "scripts"));
|
||
ensureDirectoryExists(path.join(targetDir, "tasks"));
|
||
|
||
// Setup MCP configuration for integration with Cursor
|
||
setupMCPConfiguration(targetDir);
|
||
|
||
// Copy template files with replacements
|
||
const replacements = {
|
||
year: new Date().getFullYear(),
|
||
};
|
||
|
||
// Copy .env.example
|
||
copyTemplateFile(
|
||
"env.example",
|
||
path.join(targetDir, ".env.example"),
|
||
replacements
|
||
);
|
||
|
||
// Copy .taskmasterconfig with project name, mode, and userId
|
||
copyTemplateFile(
|
||
".taskmasterconfig",
|
||
path.join(targetDir, ".taskmasterconfig"),
|
||
{
|
||
...replacements,
|
||
}
|
||
);
|
||
|
||
// Configure the .taskmasterconfig with the new settings
|
||
configureTaskmasterConfig(
|
||
targetDir,
|
||
selectedMode,
|
||
selectedPlan,
|
||
userId,
|
||
gatewayRegistration
|
||
);
|
||
|
||
// Copy .gitignore
|
||
copyTemplateFile("gitignore", path.join(targetDir, ".gitignore"));
|
||
|
||
// Copy dev_workflow.mdc
|
||
copyTemplateFile(
|
||
"dev_workflow.mdc",
|
||
path.join(targetDir, ".cursor", "rules", "dev_workflow.mdc")
|
||
);
|
||
|
||
// Copy taskmaster.mdc
|
||
copyTemplateFile(
|
||
"taskmaster.mdc",
|
||
path.join(targetDir, ".cursor", "rules", "taskmaster.mdc")
|
||
);
|
||
|
||
// Copy cursor_rules.mdc
|
||
copyTemplateFile(
|
||
"cursor_rules.mdc",
|
||
path.join(targetDir, ".cursor", "rules", "cursor_rules.mdc")
|
||
);
|
||
|
||
// Copy self_improve.mdc
|
||
copyTemplateFile(
|
||
"self_improve.mdc",
|
||
path.join(targetDir, ".cursor", "rules", "self_improve.mdc")
|
||
);
|
||
|
||
// Generate Roo rules from Cursor rules
|
||
log("info", "Generating Roo rules from Cursor rules...");
|
||
convertAllCursorRulesToRooRules(targetDir);
|
||
|
||
// Copy .windsurfrules
|
||
copyTemplateFile("windsurfrules", path.join(targetDir, ".windsurfrules"));
|
||
|
||
// Copy .roomodes for Roo Code integration
|
||
copyTemplateFile(".roomodes", path.join(targetDir, ".roomodes"));
|
||
|
||
// Copy Roo rule files for each mode
|
||
const rooModes = ["architect", "ask", "boomerang", "code", "debug", "test"];
|
||
for (const mode of rooModes) {
|
||
copyTemplateFile(
|
||
`${mode}-rules`,
|
||
path.join(targetDir, ".roo", `rules-${mode}`, `${mode}-rules`)
|
||
);
|
||
}
|
||
|
||
// Copy example_prd.txt
|
||
copyTemplateFile(
|
||
"example_prd.txt",
|
||
path.join(targetDir, "scripts", "example_prd.txt")
|
||
);
|
||
|
||
// Initialize git repository if git is available
|
||
try {
|
||
if (!fs.existsSync(path.join(targetDir, ".git"))) {
|
||
log("info", "Initializing git repository...");
|
||
execSync("git init", { stdio: "ignore" });
|
||
log("success", "Git repository initialized");
|
||
}
|
||
} catch (error) {
|
||
log("warn", "Git not available, skipping repository initialization");
|
||
}
|
||
|
||
// Run npm install automatically
|
||
const npmInstallOptions = {
|
||
cwd: targetDir,
|
||
// Default to inherit for interactive CLI, change if silent
|
||
stdio: "inherit",
|
||
};
|
||
|
||
if (isSilentMode()) {
|
||
// If silent (MCP mode), suppress npm install output
|
||
npmInstallOptions.stdio = "ignore";
|
||
log("info", "Running npm install silently..."); // Log our own message
|
||
} else {
|
||
// Interactive mode, show the boxen message
|
||
console.log(
|
||
boxen(chalk.cyan("Installing dependencies..."), {
|
||
padding: 0.5,
|
||
margin: 0.5,
|
||
borderStyle: "round",
|
||
borderColor: "blue",
|
||
})
|
||
);
|
||
}
|
||
|
||
// === Add Model Configuration Step ===
|
||
if (!isSilentMode() && !dryRun) {
|
||
// Only run model setup for BYOK mode
|
||
if (selectedMode === "byok") {
|
||
console.log(
|
||
boxen(chalk.cyan("Configuring AI Models..."), {
|
||
padding: 0.5,
|
||
margin: { top: 1, bottom: 0.5 },
|
||
borderStyle: "round",
|
||
borderColor: "blue",
|
||
})
|
||
);
|
||
log(
|
||
"info",
|
||
"Running interactive model setup. Please select your preferred AI models."
|
||
);
|
||
try {
|
||
execSync("npx task-master models --setup", {
|
||
stdio: "inherit",
|
||
cwd: targetDir,
|
||
});
|
||
log("success", "AI Models configured.");
|
||
} catch (error) {
|
||
log("error", "Failed to configure AI models:", error.message);
|
||
log(
|
||
"warn",
|
||
'You may need to run "task-master models --setup" manually.'
|
||
);
|
||
}
|
||
} else {
|
||
console.log(
|
||
boxen(
|
||
chalk.green("✅ Hosted API Gateway Configured") +
|
||
"\n\n" +
|
||
chalk.white(
|
||
"AI models are automatically available through the gateway."
|
||
) +
|
||
"\n" +
|
||
chalk.gray("No additional model configuration needed."),
|
||
{
|
||
padding: 1,
|
||
margin: { top: 1, bottom: 0.5 },
|
||
borderStyle: "round",
|
||
borderColor: "green",
|
||
}
|
||
)
|
||
);
|
||
}
|
||
} else if (isSilentMode() && !dryRun) {
|
||
log("info", "Skipping interactive model setup in silent (MCP) mode.");
|
||
if (selectedMode === "byok") {
|
||
log(
|
||
"warn",
|
||
'Please configure AI models using "task-master models --set-..." or the "models" MCP tool.'
|
||
);
|
||
}
|
||
} else if (dryRun) {
|
||
log("info", "DRY RUN: Skipping interactive model setup.");
|
||
}
|
||
// ====================================
|
||
|
||
// Display success message
|
||
if (!isSilentMode()) {
|
||
console.log(
|
||
boxen(
|
||
warmGradient.multiline(
|
||
figlet.textSync("Success!", { font: "Standard" })
|
||
) +
|
||
"\n" +
|
||
chalk.green("Project initialized successfully!"),
|
||
{
|
||
padding: 1,
|
||
margin: 1,
|
||
borderStyle: "double",
|
||
borderColor: "green",
|
||
}
|
||
)
|
||
);
|
||
}
|
||
|
||
// Display next steps based on mode
|
||
displayNextSteps(selectedMode, selectedPlan);
|
||
}
|
||
|
||
// Function to configure the .taskmasterconfig file with mode, userId, and plan settings
|
||
function configureTaskmasterConfig(
|
||
targetDir,
|
||
selectedMode,
|
||
selectedPlan,
|
||
userId,
|
||
gatewayRegistration
|
||
) {
|
||
const configPath = path.join(targetDir, ".taskmasterconfig");
|
||
|
||
try {
|
||
// Read existing config or create default structure
|
||
let config = {};
|
||
if (fs.existsSync(configPath)) {
|
||
const configContent = fs.readFileSync(configPath, "utf8");
|
||
config = JSON.parse(configContent);
|
||
}
|
||
|
||
// Ensure global section exists
|
||
if (!config.global) {
|
||
config.global = {};
|
||
}
|
||
|
||
// Ensure account section exists
|
||
if (!config.account) {
|
||
config.account = {};
|
||
}
|
||
|
||
// Store account-specific configuration
|
||
config.account.mode = selectedMode;
|
||
config.account.userId = userId || null;
|
||
config.account.email = gatewayRegistration?.email || "";
|
||
config.account.telemetryEnabled = selectedMode === "hosted";
|
||
|
||
// Store remaining global config items
|
||
config.global.logLevel = config.global.logLevel || "info";
|
||
config.global.debug = config.global.debug || false;
|
||
config.global.defaultSubtasks = config.global.defaultSubtasks || 5;
|
||
config.global.defaultPriority = config.global.defaultPriority || "medium";
|
||
config.global.projectName = config.global.projectName || "Taskmaster";
|
||
config.global.ollamaBaseURL =
|
||
config.global.ollamaBaseURL || "http://localhost:11434/api";
|
||
config.global.azureBaseURL =
|
||
config.global.azureBaseURL || "https://your-endpoint.azure.com/";
|
||
|
||
// Write updated config
|
||
fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
|
||
log("info", `Updated .taskmasterconfig with mode: ${selectedMode}`);
|
||
|
||
return config;
|
||
} catch (error) {
|
||
log("error", `Error configuring .taskmasterconfig: ${error.message}`);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
// Function to display next steps based on the selected mode
|
||
function displayNextSteps(selectedMode, selectedPlan) {
|
||
if (isSilentMode()) return;
|
||
|
||
if (selectedMode === "hosted") {
|
||
// Hosted mode next steps
|
||
console.log(
|
||
boxen(
|
||
chalk.cyan.bold("🚀 Your Hosted Gateway is Ready!") +
|
||
"\n\n" +
|
||
chalk.white("1. ") +
|
||
chalk.yellow("Create your PRD using the example template:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("Edit ") +
|
||
chalk.cyan("scripts/example_prd.txt") +
|
||
chalk.dim(" and save as ") +
|
||
chalk.cyan("scripts/prd.txt") +
|
||
"\n" +
|
||
chalk.white("2. ") +
|
||
chalk.yellow("Generate tasks from your PRD:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("MCP Tool: ") +
|
||
chalk.cyan("parse_prd") +
|
||
chalk.dim(" | CLI: ") +
|
||
chalk.cyan("task-master parse-prd scripts/prd.txt") +
|
||
"\n" +
|
||
chalk.white("3. ") +
|
||
chalk.yellow("Analyze task complexity:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("MCP Tool: ") +
|
||
chalk.cyan("analyze_project_complexity") +
|
||
chalk.dim(" | CLI: ") +
|
||
chalk.cyan("task-master analyze-complexity --research") +
|
||
"\n" +
|
||
chalk.white("4. ") +
|
||
chalk.yellow("Expand tasks into subtasks:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("MCP Tool: ") +
|
||
chalk.cyan("expand_all") +
|
||
chalk.dim(" | CLI: ") +
|
||
chalk.cyan("task-master expand --all --research") +
|
||
"\n" +
|
||
chalk.white("5. ") +
|
||
chalk.yellow("Start building:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("MCP Tool: ") +
|
||
chalk.cyan("next_task") +
|
||
chalk.dim(" | CLI: ") +
|
||
chalk.cyan("task-master next") +
|
||
"\n\n" +
|
||
chalk.green.bold("💡 Pro Tip: ") +
|
||
chalk.white("All AI models are ready to use - no API keys needed!") +
|
||
"\n" +
|
||
(selectedPlan
|
||
? chalk.blue(
|
||
`📊 Your Plan: ${selectedPlan.name} (${selectedPlan.credits} credits/month)`
|
||
)
|
||
: ""),
|
||
{
|
||
padding: 1,
|
||
margin: 1,
|
||
borderStyle: "round",
|
||
borderColor: "green",
|
||
title: "🎯 Getting Started - Hosted Mode",
|
||
titleAlignment: "center",
|
||
}
|
||
)
|
||
);
|
||
} else {
|
||
// BYOK mode next steps
|
||
console.log(
|
||
boxen(
|
||
chalk.cyan.bold("🔑 BYOK Mode Setup Complete!") +
|
||
"\n\n" +
|
||
chalk.white("1. ") +
|
||
chalk.yellow("Add your API keys to the ") +
|
||
chalk.cyan(".env") +
|
||
chalk.yellow(" file:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("Copy from ") +
|
||
chalk.cyan(".env.example") +
|
||
chalk.dim(" and add your keys") +
|
||
"\n" +
|
||
chalk.white("2. ") +
|
||
chalk.yellow("Create your PRD using the example template:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("Edit ") +
|
||
chalk.cyan("scripts/example_prd.txt") +
|
||
chalk.dim(" and save as ") +
|
||
chalk.cyan("scripts/prd.txt") +
|
||
"\n" +
|
||
chalk.white("3. ") +
|
||
chalk.yellow("Generate tasks from your PRD:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("MCP Tool: ") +
|
||
chalk.cyan("parse_prd") +
|
||
chalk.dim(" | CLI: ") +
|
||
chalk.cyan("task-master parse-prd scripts/prd.txt") +
|
||
"\n" +
|
||
chalk.white("4. ") +
|
||
chalk.yellow("Analyze task complexity:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("MCP Tool: ") +
|
||
chalk.cyan("analyze_project_complexity") +
|
||
chalk.dim(" | CLI: ") +
|
||
chalk.cyan("task-master analyze-complexity --research") +
|
||
"\n" +
|
||
chalk.white("5. ") +
|
||
chalk.yellow("Expand tasks into subtasks:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("MCP Tool: ") +
|
||
chalk.cyan("expand_all") +
|
||
chalk.dim(" | CLI: ") +
|
||
chalk.cyan("task-master expand --all --research") +
|
||
"\n" +
|
||
chalk.white("6. ") +
|
||
chalk.yellow("Start building:") +
|
||
"\n" +
|
||
chalk.white(" └─ ") +
|
||
chalk.dim("MCP Tool: ") +
|
||
chalk.cyan("next_task") +
|
||
chalk.dim(" | CLI: ") +
|
||
chalk.cyan("task-master next") +
|
||
"\n\n" +
|
||
chalk.blue.bold("💡 Pro Tip: ") +
|
||
chalk.white("Use ") +
|
||
chalk.cyan("task-master models") +
|
||
chalk.white(" to view/change AI models anytime") +
|
||
"\n" +
|
||
chalk.dim("* For MCP/Cursor: Add API keys to ") +
|
||
chalk.cyan(".cursor/mcp.json") +
|
||
chalk.dim(" instead"),
|
||
{
|
||
padding: 1,
|
||
margin: 1,
|
||
borderStyle: "round",
|
||
borderColor: "blue",
|
||
title: "🎯 Getting Started - BYOK Mode",
|
||
titleAlignment: "center",
|
||
}
|
||
)
|
||
);
|
||
}
|
||
}
|
||
|
||
// Function to setup MCP configuration for Cursor integration
|
||
function setupMCPConfiguration(targetDir) {
|
||
const mcpDirPath = path.join(targetDir, ".cursor");
|
||
const mcpJsonPath = path.join(mcpDirPath, "mcp.json");
|
||
|
||
log("info", "Setting up MCP configuration for Cursor integration...");
|
||
|
||
// Create .cursor directory if it doesn't exist
|
||
ensureDirectoryExists(mcpDirPath);
|
||
|
||
// New MCP config to be added - references the installed package
|
||
const newMCPServer = {
|
||
"task-master-ai": {
|
||
command: "npx",
|
||
args: ["-y", "--package=task-master-ai", "task-master-ai"],
|
||
env: {
|
||
ANTHROPIC_API_KEY: "ANTHROPIC_API_KEY_HERE",
|
||
PERPLEXITY_API_KEY: "PERPLEXITY_API_KEY_HERE",
|
||
OPENAI_API_KEY: "OPENAI_API_KEY_HERE",
|
||
GOOGLE_API_KEY: "GOOGLE_API_KEY_HERE",
|
||
XAI_API_KEY: "XAI_API_KEY_HERE",
|
||
OPENROUTER_API_KEY: "OPENROUTER_API_KEY_HERE",
|
||
MISTRAL_API_KEY: "MISTRAL_API_KEY_HERE",
|
||
AZURE_OPENAI_API_KEY: "AZURE_OPENAI_API_KEY_HERE",
|
||
OLLAMA_API_KEY: "OLLAMA_API_KEY_HERE",
|
||
},
|
||
},
|
||
};
|
||
|
||
// Check if mcp.json already existsimage.png
|
||
if (fs.existsSync(mcpJsonPath)) {
|
||
log(
|
||
"info",
|
||
"MCP configuration file already exists, checking for existing task-master-mcp..."
|
||
);
|
||
try {
|
||
// Read existing config
|
||
const mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, "utf8"));
|
||
|
||
// Initialize mcpServers if it doesn't exist
|
||
if (!mcpConfig.mcpServers) {
|
||
mcpConfig.mcpServers = {};
|
||
}
|
||
|
||
// Check if any existing server configuration already has task-master-mcp in its args
|
||
const hasMCPString = Object.values(mcpConfig.mcpServers).some(
|
||
(server) =>
|
||
server.args &&
|
||
server.args.some(
|
||
(arg) => typeof arg === "string" && arg.includes("task-master-ai")
|
||
)
|
||
);
|
||
|
||
if (hasMCPString) {
|
||
log(
|
||
"info",
|
||
"Found existing task-master-ai MCP configuration in mcp.json, leaving untouched"
|
||
);
|
||
return; // Exit early, don't modify the existing configuration
|
||
}
|
||
|
||
// Add the task-master-ai server if it doesn't exist
|
||
if (!mcpConfig.mcpServers["task-master-ai"]) {
|
||
mcpConfig.mcpServers["task-master-ai"] = newMCPServer["task-master-ai"];
|
||
log(
|
||
"info",
|
||
"Added task-master-ai server to existing MCP configuration"
|
||
);
|
||
} else {
|
||
log("info", "task-master-ai server already configured in mcp.json");
|
||
}
|
||
|
||
// Write the updated configuration
|
||
fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 4));
|
||
log("success", "Updated MCP configuration file");
|
||
} catch (error) {
|
||
log("error", `Failed to update MCP configuration: ${error.message}`);
|
||
// Create a backup before potentially modifying
|
||
const backupPath = `${mcpJsonPath}.backup-${Date.now()}`;
|
||
if (fs.existsSync(mcpJsonPath)) {
|
||
fs.copyFileSync(mcpJsonPath, backupPath);
|
||
log("info", `Created backup of existing mcp.json at ${backupPath}`);
|
||
}
|
||
|
||
// Create new configuration
|
||
const newMCPConfig = {
|
||
mcpServers: newMCPServer,
|
||
};
|
||
|
||
fs.writeFileSync(mcpJsonPath, JSON.stringify(newMCPConfig, null, 4));
|
||
log(
|
||
"warn",
|
||
"Created new MCP configuration file (backup of original file was created if it existed)"
|
||
);
|
||
}
|
||
} else {
|
||
// If mcp.json doesn't exist, create it
|
||
const newMCPConfig = {
|
||
mcpServers: newMCPServer,
|
||
};
|
||
|
||
fs.writeFileSync(mcpJsonPath, JSON.stringify(newMCPConfig, null, 4));
|
||
log("success", "Created MCP configuration file for Cursor integration");
|
||
}
|
||
|
||
// Add note to console about MCP integration
|
||
log("info", "MCP server will use the installed task-master-ai package");
|
||
}
|
||
|
||
// Function to handle hosted subscription with browser pattern
|
||
async function handleHostedSubscription() {
|
||
const planResponse = await inquirer.prompt([
|
||
{
|
||
type: "list",
|
||
name: "plan",
|
||
message: "Select Your Monthly AI Credit Pack:",
|
||
choices: [
|
||
{
|
||
name: "50 credits - $5/mo [$0.10 per credit] - Perfect for personal projects",
|
||
value: { name: "Starter", credits: 50, price: "$5/mo", value: 1 },
|
||
},
|
||
{
|
||
name: "120 credits - $10/mo [$0.083 per credit] - Popular choice",
|
||
value: { name: "Popular", credits: 120, price: "$10/mo", value: 2 },
|
||
},
|
||
{
|
||
name: "250 credits - $20/mo [$0.08 per credit] - Great value",
|
||
value: { name: "Pro", credits: 250, price: "$20/mo", value: 3 },
|
||
},
|
||
{
|
||
name: "550 credits - $40/mo [$0.073 per credit] - Best value",
|
||
value: {
|
||
name: "Enterprise",
|
||
credits: 550,
|
||
price: "$40/mo",
|
||
value: 4,
|
||
},
|
||
},
|
||
],
|
||
default: 1, // Popular plan
|
||
},
|
||
]);
|
||
|
||
const selectedPlan = planResponse.plan;
|
||
|
||
console.log(
|
||
boxen(
|
||
chalk.green.bold(`✅ Selected: ${selectedPlan.name} Plan`) +
|
||
"\n\n" +
|
||
chalk.white(
|
||
`${selectedPlan.credits} credits/month for ${selectedPlan.price}`
|
||
) +
|
||
"\n\n" +
|
||
chalk.yellow("🔄 Opening browser for Stripe checkout...") +
|
||
"\n" +
|
||
chalk.dim("Complete your subscription setup in the browser."),
|
||
{
|
||
padding: 1,
|
||
margin: { top: 0.5, bottom: 0.5 },
|
||
borderStyle: "round",
|
||
borderColor: "green",
|
||
}
|
||
)
|
||
);
|
||
|
||
// Stripe simulation with browser opening pattern (like Shopify CLI)
|
||
await simulateStripeCheckout(selectedPlan);
|
||
|
||
return selectedPlan;
|
||
}
|
||
|
||
// Stripe checkout simulation with browser pattern
|
||
async function simulateStripeCheckout(plan) {
|
||
console.log(chalk.yellow("\n⏳ Starting Stripe checkout process..."));
|
||
|
||
// Start a simple HTTP server to handle the callback
|
||
const app = express();
|
||
let server;
|
||
let checkoutComplete = false;
|
||
|
||
// For demo/testing, we'll use a simple success simulation
|
||
const checkoutUrl = `https://example-stripe-simulation.com/checkout?plan=${plan.value}&return_url=http://localhost:3333/success`;
|
||
|
||
app.get("/success", (req, res) => {
|
||
checkoutComplete = true;
|
||
res.send(`
|
||
<html>
|
||
<body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
|
||
<h1 style="color: #28a745;">✅ Subscription Complete!</h1>
|
||
<p>Your ${plan.name} plan (${plan.credits} credits/month) is now active.</p>
|
||
<p style="color: #666; margin-top: 30px;">You can close this window and return to your terminal.</p>
|
||
</body>
|
||
</html>
|
||
`);
|
||
setTimeout(() => {
|
||
server.close();
|
||
}, 1000);
|
||
});
|
||
|
||
// Start the callback server
|
||
server = app.listen(3333, () => {
|
||
console.log(chalk.blue("📡 Started local callback server on port 3333"));
|
||
});
|
||
|
||
// Prompt user before opening browser
|
||
await inquirer.prompt([
|
||
{
|
||
type: "input",
|
||
name: "ready",
|
||
message: chalk.cyan(
|
||
"Press Enter to open your browser for Stripe checkout..."
|
||
),
|
||
},
|
||
]);
|
||
|
||
// Open the browser (for demo, we'll simulate immediate success)
|
||
console.log(chalk.blue("🌐 Opening browser..."));
|
||
|
||
// For demo purposes, simulate immediate success instead of opening real browser
|
||
// In real implementation: await open(checkoutUrl);
|
||
console.log(chalk.gray(`Demo URL: ${checkoutUrl}`));
|
||
|
||
// Simulate the checkout completion after 2 seconds
|
||
setTimeout(() => {
|
||
console.log(chalk.green("✅ Subscription setup complete! (Simulated)"));
|
||
checkoutComplete = true;
|
||
server.close();
|
||
}, 2000);
|
||
|
||
// Wait for checkout completion
|
||
while (!checkoutComplete) {
|
||
await new Promise((resolve) => setTimeout(resolve, 500));
|
||
}
|
||
|
||
console.log(chalk.green("🎉 Payment successful! Continuing setup..."));
|
||
}
|
||
|
||
// Ensure necessary functions are exported
|
||
export { initializeProject, log }; // Only export what's needed by commands.js
|