dominds 0.1.0

package/dist/cli/tui.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * TUI subcommand for dominds CLI
+ *
+ * Usage:
+ *   dominds tui [options] <taskdoc-path> [prompts...]
+ *   dominds run [options] <taskdoc-path> [prompts...]
+ *
+ * Options:
+ *   -m, --member <id>: Specify team member ID to use as agent
+ *   -i, --id <dialog-id>: Resume existing dialog or use custom dialog ID
+ *   --list: List all dialogs (running, completed, archived)
+ *   --help: Show help message
+ *   -p, --print-only: Non-interactive mode (for automated testing)
+ *   --version: Show version information
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const log_1 = require("../log");
+// Helper function to get package version
+function getPackageVersion() {
+    try {
+        const packagePath = path.join(__dirname, '../package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        return packageJson.version || 'unknown';
+    }
+    catch (error) {
+        return 'unknown';
+    }
+}
+function showVersion() {
+    console.log(`dominds v${getPackageVersion()}`);
+}
+function showHelp() {
+    console.log(`dominds v${getPackageVersion()}`);
+    console.log('');
+    console.log('Usage: dominds tui [options] [taskdoc] [prompt]');
+    console.log('       dominds run [options] [taskdoc] [prompt]');
+    console.log('');
+    console.log('Start or continue a dialog with an AI team member using a Taskdoc.');
+    console.log('');
+    console.log("Note: Workspace directory is `process.cwd()`. Use 'dominds -C <dir> tui ...' to run in another workspace.");
+    console.log('');
+    console.log('Arguments:');
+    console.log('  <taskdoc-path>    Path to Taskdoc (required for dialog)');
+    console.log('  [prompts...]      Optional initial prompts');
+    console.log('');
+    console.log('Options:');
+    console.log('  -m <member>            Specify team member');
+    console.log('  -i <dialog-id>         Resume dialog with specified ID');
+    console.log('  -p, --print-only       Non-interactive mode (for automated testing)');
+    console.log('  --list                 List all dialogs');
+    console.log('  --version              Show version information');
+    console.log('  --help                 Show this help message');
+    console.log('');
+    console.log('Examples:');
+    console.log('  dominds tui task.tsk "implement feature"');
+    console.log('  dominds tui -i abc123');
+    console.log('  dominds tui --list');
+    console.log('  dominds tui --version');
+    console.log('');
+    console.log('Note: All bare arguments (without -- prefix) are treated as Taskdocs');
+    console.log('      or prompts, ensuring no conflicts with user files.');
+}
+function parseArgs(argv) {
+    const out = { prompts: [] };
+    let inOptions = true;
+    let taskDocPathSet = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (inOptions) {
+            if (a === '--') {
+                inOptions = false;
+                continue;
+            }
+            if (a === '-m' || a === '--member') {
+                const next = argv[i + 1];
+                if (next == null) {
+                    throw new Error(`${a} requires a team member ID argument`);
+                }
+                out.member = next;
+                i++;
+                continue;
+            }
+            if (a === '-i' || a === '--id') {
+                const next = argv[i + 1];
+                if (next == null) {
+                    throw new Error(`${a} requires a dialog ID argument`);
+                }
+                out.dialogId = next;
+                i++;
+                continue;
+            }
+            if (a === '--list') {
+                out.list = true;
+                continue;
+            }
+            if (a === '--version') {
+                out.version = true;
+                continue;
+            }
+            if (a === '--help' || a === '-h') {
+                out.help = true;
+                continue;
+            }
+            if (a === '-p' || a === '--print-only') {
+                out.nonInteractive = true;
+                continue;
+            }
+            if (a.startsWith('-')) {
+                throw new Error(`Unknown option: ${a}`);
+            }
+            // Check for invalid commands that look like commands but aren't recognized
+            if (a.includes('-') && !a.includes('.') && !a.includes('/')) {
+                throw new Error(`Unknown command: ${a}. Use --help to see available commands.`);
+            }
+            // First non-option token is mandatory taskDocPath
+            if (!taskDocPathSet) {
+                out.taskDocPath = a;
+                taskDocPathSet = true;
+                continue;
+            }
+            // Subsequent non-option tokens before -- count as prompts
+            out.prompts.push(a);
+            continue;
+        }
+        // After --, treat everything as prompt fragments (including dash-started)
+        out.prompts.push(a);
+    }
+    return out;
+}
+async function main() {
+    try {
+        const args = parseArgs(process.argv.slice(2));
+        // Handle version flag
+        if (args.version) {
+            showVersion();
+            return;
+        }
+        // Handle help flag
+        if (args.help) {
+            showHelp();
+            return;
+        }
+        if (args.taskDocPath && !args.list) {
+            const normalized = args.taskDocPath.replace(/\\/g, '/').replace(/\/+$/g, '');
+            if (!normalized.endsWith('.tsk')) {
+                throw new Error(`taskdoc-path must be a Taskdoc directory ending in '.tsk' (got: '${args.taskDocPath}')`);
+            }
+        }
+        console.log(`Dominds TUI not implemented yet.`);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+if (require.main === module) {
+    main().catch((error) => {
+        log_1.log.error('CLI execution failed', error);
+        process.exit(1);
+    });
+}

package/dist/cli/webui.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * WebUI subcommand for dominds CLI
+ *
+ * Usage:
+ *   dominds webui [options]
+ *
+ * Options:
+ *   -p, --port <port>    Port to listen on (default: 5666)
+ *   -h, --host <host>    Host to bind to (default: localhost)
+ *   --nobrowser          Do not open a browser (opt-out)
+ *   -h, --help           Show help
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const child_process_1 = require("child_process");
+const log_1 = require("../log");
+const server_1 = require("../server");
+const auth_1 = require("../server/auth");
+const runtime_language_1 = require("../shared/runtime-language");
+const log = (0, log_1.createLogger)('webui');
+function printHelp() {
+    console.log(`
+WebUI Server for dominds
+
+Usage:
+  dominds webui [options]
+
+Note:
+  Workspace directory is \`process.cwd()\`. Use 'dominds -C <dir> webui' to run in another workspace.
+
+Options:
+  -p, --port <port>    Port to listen on (default: 5666)
+  -h, --host <host>    Host to bind to (default: localhost)
+  --mode <dev|prod>    Server mode (default: prod; dev if NODE_ENV=dev)
+  --nobrowser          Do not open a browser (opt-out)
+  --help               Show this help message
+
+Examples:
+  dominds webui                   # Start on default port 5666
+  dominds webui -p 8888           # Start on port 8888
+  dominds webui --mode dev        # Start in dev mode
+  dominds webui --nobrowser       # Start without opening a browser
+`);
+}
+function openInBrowser(url) {
+    // Best-effort cross-platform open.
+    // We intentionally do not await; failures should not crash the server.
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        (0, child_process_1.spawn)('open', [url], { stdio: 'ignore', detached: true }).unref();
+        return;
+    }
+    if (platform === 'win32') {
+        (0, child_process_1.spawn)('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true }).unref();
+        return;
+    }
+    (0, child_process_1.spawn)('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+}
+async function main() {
+    const args = process.argv.slice(2);
+    let port = 5666;
+    let host = 'localhost';
+    let mode = process.env.NODE_ENV === 'dev' ? 'dev' : 'prod';
+    let shouldOpen = true;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-p' || arg === '--port') {
+            const next = args[i + 1];
+            if (!next || isNaN(parseInt(next))) {
+                console.error('Error: --port requires a valid port number');
+                printHelp();
+                process.exit(1);
+            }
+            port = parseInt(next);
+            i++;
+        }
+        else if (arg === '-h' || arg === '--host') {
+            const next = args[i + 1];
+            if (!next) {
+                console.error('Error: --host requires a hostname');
+                printHelp();
+                process.exit(1);
+            }
+            host = next;
+            i++;
+        }
+        else if (arg === '--mode') {
+            const next = args[i + 1];
+            if (next !== 'dev' && next !== 'prod') {
+                console.error(`Error: --mode must be 'dev' or 'prod'`);
+                printHelp();
+                process.exit(1);
+            }
+            mode = next;
+            i++;
+        }
+        else if (arg === '--nobrowser') {
+            shouldOpen = false;
+        }
+        else if (arg === '--help') {
+            printHelp();
+            process.exit(0);
+        }
+        else {
+            console.error(`Error: Unknown option '${arg}'`);
+            printHelp();
+            process.exit(1);
+        }
+    }
+    log.info('Starting Dominds WebUI…');
+    try {
+        const { language: resolvedLanguage, source } = (0, runtime_language_1.resolveWorkLanguage)({ env: process.env });
+        (0, runtime_language_1.setWorkLanguage)(resolvedLanguage);
+        log.info(`working language: ${(0, runtime_language_1.getWorkLanguage)()} (source: ${source})`);
+        const started = await (0, server_1.startServer)({ port, host, mode });
+        const httpServer = started.httpServer;
+        const auth = started.auth;
+        const baseUrl = `http://${started.host}:${started.port}`;
+        log.info(`WebUI ready: ${baseUrl}`);
+        log.debug(`WebSocket endpoint: ws://${started.host}:${started.port}/ws`);
+        if (auth.kind === 'enabled') {
+            const autoAuthUrl = (0, auth_1.formatAutoAuthUrl)({
+                host: started.host,
+                port: started.port,
+                authKey: auth.key,
+            });
+            log.info(`auto auth url (sensitive): ${autoAuthUrl}`);
+            if (shouldOpen) {
+                log.debug(`Opening browser: ${autoAuthUrl}`);
+                openInBrowser(autoAuthUrl);
+            }
+        }
+        else {
+            log.info('auth: disabled');
+            if (shouldOpen) {
+                const url = `${baseUrl}/`;
+                log.debug(`Opening browser: ${url}`);
+                openInBrowser(url);
+            }
+        }
+        // Handle graceful shutdown
+        process.on('SIGINT', () => {
+            log.info('Shutting down WebUI server...');
+            httpServer.stop().then(() => {
+                log.info('WebUI server stopped');
+                process.exit(0);
+            });
+        });
+        process.on('SIGTERM', () => {
+            log.info('Shutting down WebUI server...');
+            httpServer.stop().then(() => {
+                log.info('WebUI server stopped');
+                process.exit(0);
+            });
+        });
+    }
+    catch (err) {
+        console.error('Failed to start WebUI server:', err);
+        process.exit(1);
+    }
+}
+if (require.main === module) {
+    main().catch((err) => {
+        console.error('Unhandled error:', err);
+        process.exit(1);
+    });
+}

package/dist/cli.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Main CLI entry point for dominds
+ *
+ * Usage:
+ *   dominds [subcommand] [options]
+ *
+ * Subcommands:
+ *   webui    - Start WebUI server (default)
+ *   tui      - Start Text User Interface
+ *   run      - Run task dialog (alias for tui)
+ *   read     - Read team configuration
+ *   create   - Create a new workspace from a template
+ *   new      - Alias for create
+ *   help     - Show help
+ *
+ * Global installation:
+ *   pnpm add -g dominds
+ *   dominds webui
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const create_1 = require("./cli/create");
+const read_1 = require("./cli/read");
+const tui_1 = require("./cli/tui");
+const webui_1 = require("./cli/webui");
+const dotenv_1 = require("./shared/dotenv");
+const rtws_cli_1 = require("./shared/rtws-cli");
+require("./tools/builtins");
+function printHelp() {
+    console.log(`
+Dominds CLI - AI-driven DevOps framework with persistent memory
+
+Usage:
+  dominds [-C <dir>] [subcommand] [options]
+
+Global Options:
+  -C <dir>            Change to workspace directory (rtws) before running
+
+Subcommands:
+  webui [options]    Start WebUI server (default)
+  tui [options]      Start Text User Interface
+  run [options]      Run task dialog (alias for tui)
+  read [options]     Read team configuration
+  create [options]   Create a new workspace from a template
+  new [options]      Alias for create
+  help               Show this help message
+
+Examples:
+  dominds                    # Start WebUI server (default)
+  dominds webui              # Start WebUI server
+  dominds -C ./my-ws webui   # Start in specific workspace
+  dominds tui --help         # Show TUI help
+  dominds run task.tsk       # Run task dialog
+  dominds read               # Read team configuration
+  dominds create web-scaffold my-project   # Create workspace from a template
+
+Installation:
+  pnpm add -g dominds
+
+For detailed help on a specific subcommand:
+  dominds <subcommand> --help
+`);
+}
+function printVersion() {
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+        console.log(`dominds v${packageJson.version}`);
+    }
+    catch {
+        console.log('dominds (version unknown)');
+    }
+}
+async function main() {
+    const baseCwd = process.cwd();
+    let parsed;
+    try {
+        parsed = (0, rtws_cli_1.extractGlobalRtwsChdir)({ argv: process.argv.slice(2), baseCwd });
+    }
+    catch (err) {
+        console.error('Error:', err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    const args = parsed.argv;
+    // Handle no arguments - default to webui
+    if (args.length === 0) {
+        if (parsed.chdir) {
+            try {
+                const absoluteRtwsRoot = path.isAbsolute(parsed.chdir)
+                    ? parsed.chdir
+                    : path.resolve(baseCwd, parsed.chdir);
+                process.chdir(absoluteRtwsRoot);
+            }
+            catch (err) {
+                console.error(`Error: failed to change directory to '${parsed.chdir}':`, err);
+                process.exit(1);
+            }
+        }
+        (0, dotenv_1.loadRtwsDotenv)({ cwd: process.cwd() });
+        await runSubcommand('webui', []);
+        return;
+    }
+    const subcommand = args[0];
+    const subcommandArgs = args.slice(1);
+    // Handle help and version flags
+    if (subcommand === '-h' || subcommand === '--help' || subcommand === 'help') {
+        printHelp();
+        process.exit(0);
+    }
+    if (subcommand === '-v' || subcommand === '--version') {
+        printVersion();
+        process.exit(0);
+    }
+    const shouldSkipRtwsSetup = subcommandArgs.includes('--help') ||
+        (subcommand === 'tui' && subcommandArgs.includes('-h')) ||
+        (subcommand === 'run' && subcommandArgs.includes('-h')) ||
+        (subcommand === 'read' && subcommandArgs.includes('-h')) ||
+        ((subcommand === 'create' || subcommand === 'new') && subcommandArgs.includes('-h'));
+    if (!shouldSkipRtwsSetup) {
+        if (parsed.chdir) {
+            try {
+                const absoluteRtwsRoot = path.isAbsolute(parsed.chdir)
+                    ? parsed.chdir
+                    : path.resolve(baseCwd, parsed.chdir);
+                process.chdir(absoluteRtwsRoot);
+            }
+            catch (err) {
+                console.error(`Error: failed to change directory to '${parsed.chdir}':`, err);
+                process.exit(1);
+            }
+        }
+        // Load runtime workspace env files into process.env once, in the main entry.
+        // Precedence: `.env` then `.env.local` (later overwrites earlier), and both
+        // overwrite any existing process.env values.
+        (0, dotenv_1.loadRtwsDotenv)({ cwd: process.cwd() });
+    }
+    // Route to appropriate subcommand
+    switch (subcommand) {
+        case 'webui':
+            await runSubcommand('webui', subcommandArgs);
+            break;
+        case 'tui':
+        case 'run':
+            await runSubcommand('tui', subcommandArgs);
+            break;
+        case 'read':
+            await runSubcommand('read', subcommandArgs);
+            break;
+        case 'create':
+        case 'new':
+            await runSubcommand('create', subcommandArgs);
+            break;
+        default:
+            console.error(`Error: Unknown subcommand '${subcommand}'`);
+            console.error(`Run 'dominds help' for usage information.`);
+            process.exit(1);
+    }
+}
+async function runSubcommand(subcommand, args) {
+    try {
+        // Save original argv
+        const originalArgv = process.argv;
+        // Set argv to simulate direct execution of the subcommand
+        process.argv = ['node', subcommand, ...args];
+        if (subcommand === 'webui') {
+            await (0, webui_1.main)();
+        }
+        else if (subcommand === 'tui') {
+            await (0, tui_1.main)();
+        }
+        else if (subcommand === 'read') {
+            await (0, read_1.main)();
+        }
+        else if (subcommand === 'create') {
+            await (0, create_1.main)();
+        }
+        else {
+            console.error(`Error: Subcommand '${subcommand}' not implemented`);
+            process.exit(1);
+        }
+        // Restore original argv
+        process.argv = originalArgv;
+    }
+    catch (err) {
+        console.error(`Failed to execute subcommand '${subcommand}':`, err);
+        process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error('Unhandled error:', err);
+    process.exit(1);
+});

package/dist/dialog-factory.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogFactory = void 0;
+/**
+ * Module: dialog-factory
+ *
+ * Factory for creating Dialog instances with proper type hierarchy.
+ * Provides a single point of dialog creation to ensure consistent initialization.
+ */
+const dialog_1 = require("./dialog");
+const dialog_global_registry_1 = require("./dialog-global-registry");
+const id_1 = require("./utils/id");
+/**
+ * Factory for creating Dialog instances.
+ * Abstracts the creation of RootDialog and SubDialog with proper type hierarchy.
+ */
+class DialogFactory {
+    /**
+     * Create a new RootDialog instance.
+     */
+    static createRootDialog(dlgStore, taskDocPath, agentId, id, initialState) {
+        const rootDialog = new dialog_1.RootDialog(dlgStore, taskDocPath, id, agentId, initialState);
+        dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+        return rootDialog;
+    }
+    /**
+     * Create a new SubDialog instance.
+     */
+    static createSubDialog(supdialog, taskDocPath, targetAgentId, headLine, callBody, options, initialState) {
+        const generatedId = (0, id_1.generateDialogID)();
+        const subdialogId = new dialog_1.DialogID(generatedId, supdialog.id.rootId);
+        return new dialog_1.SubDialog(supdialog.dlgStore, supdialog, taskDocPath, subdialogId, targetAgentId, {
+            headLine,
+            callBody,
+            originMemberId: options.originMemberId,
+            callerDialogId: options.callerDialogId,
+            callId: options.callId,
+        }, options.tellaskSession, initialState);
+    }
+    /**
+     * Check if a dialog is a RootDialog.
+     */
+    static isRootDialog(dialog) {
+        return dialog instanceof dialog_1.RootDialog;
+    }
+    /**
+     * Check if a dialog is a SubDialog.
+     */
+    static isSubDialog(dialog) {
+        return dialog instanceof dialog_1.SubDialog;
+    }
+}
+exports.DialogFactory = DialogFactory;