@taskforcehq/taskforce 0.3.168

package/dist/plugins/vite.js

@@ -0,0 +1,271 @@
+/**
+ * Taskforce Vite Plugin
+ *
+ * Handles task operations during development by reading/writing JSON files.
+ * Uses TaskforceCore for logic, acting as an HTTP adapter.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { TaskforceCore } from '../core/Taskforce.js';
+import { createRoutes, matchRoute } from '../server/routes.js';
+import { resolveDatabaseConfigFromEnv } from '../storage/providerConfig.js';
+import { resolveObjectStorageConfigFromEnv } from '../storage/objectStorageConfig.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// @ts-ignore
+import pkg from '../../package.json' with { type: 'json' };
+const { version } = pkg;
+/**
+ * Vite plugin for Taskforce file operations
+ *
+ * Uses project root (parent of frontend/) as base path for file operations.
+ * Default storage path: .taskforce/ (for AI agent accessibility)
+ */
+export function taskforcePlugin(options) {
+    console.log(`\x1b[35m[Taskforce] v${version} initialized${options?.mode ? ` (${options.mode})` : ''}\x1b[0m`);
+    const hostRoot = options?.hostRoot;
+    const mode = options?.mode || 'app';
+    // Project root detection:
+    // Priority 1: Use hostRoot if provided (for CLI usage)
+    // Priority 2: Use process.cwd() (for standalone projects)
+    let projectRoot;
+    if (hostRoot) {
+        projectRoot = hostRoot;
+        console.log('[Taskforce] Using provided host root:', projectRoot);
+    }
+    else {
+        projectRoot = process.cwd();
+        console.log('[Taskforce] Using current working directory:', projectRoot);
+    }
+    // Resolve to real path to handle symlinks
+    if (fs.existsSync(projectRoot)) {
+        projectRoot = fs.realpathSync(projectRoot);
+    }
+    const db = resolveDatabaseConfigFromEnv();
+    // Initialize Core
+    const core = new TaskforceCore({
+        projectRoot,
+        storagePath: options?.outputPath,
+        tenantId: process.env.TASKFORCE_TENANT_ID || 'default',
+        database: {
+            provider: db.provider,
+            connectionString: db.connectionString
+        }
+    });
+    const { screenshotsDir, basePath } = core.getPaths();
+    return {
+        name: 'taskforce',
+        handleHotUpdate({ file, server }) {
+            if (file.startsWith(basePath) && (file.endsWith('.json') || file.endsWith('.md'))) {
+                server.ws.send({
+                    type: 'custom',
+                    event: 'taskforce:update',
+                    data: { file }
+                });
+                return []; // Return empty array to stop HMR propagation/reload
+            }
+        },
+        configureServer(server) {
+            // Hot Module Replacement for Taskforce data
+            // Listen for changes in the storage directory and notify client
+            server.watcher.add(basePath);
+            server.watcher.on('change', (file) => {
+                if (file.startsWith(basePath) && (file.endsWith('.json') || file.endsWith('.md'))) {
+                    server.ws.send({
+                        type: 'custom',
+                        event: 'taskforce:update',
+                        data: { file }
+                    });
+                }
+            });
+            // 1. Serve static assets (favicon, logo) from package dist/public or project root
+            server.middlewares.use((req, res, next) => {
+                const url = req.url || '';
+                // FIX: Do not intercept requests for source files (e.g., /src/...)
+                // Vite needs to handle these to transform them into JS modules when imported.
+                // If we serve them as raw images here, the browser receives an image when it expects a module, causing MIME type errors.
+                if (url.startsWith('/src/') || url.startsWith('/node_modules/') || url.startsWith('/@')) {
+                    return next();
+                }
+                // Check if the request is for our branded assets
+                if (url.includes('favicon.png') || url.includes('logo.svg') || url.includes('logo.png') || url.includes('logo.jpg') || url.includes('favicon.ico')) {
+                    // Priority list for project assets
+                    const projectAssets = [
+                        'logo.svg',
+                        'logo.png',
+                        'logo.jpg',
+                        'favicon.png',
+                        'favicon.ico'
+                    ];
+                    const requestedFile = path.basename(url.split('?')[0]);
+                    // 1. Check PROJECT public/ folder (User's assets)
+                    // We check for ANY of the supported assets if the request corresponds to our generic "logo" concept
+                    // But to keep it simple, if they ask for /favicon.png, we look for favicon.png.
+                    // However, we want to allow the frontend to blindly ask for "/logo.png" (or similar) and get the BEST available logo.
+                    // Strategy:
+                    // If request is specifically for "logo.svg" (or the generic logo endpoint we decide on), we try to find the best logo.
+                    // If request is for "favicon.png", we try to find the best favicon.
+                    const projectPublic = path.join(projectRoot, 'public');
+                    if (fs.existsSync(projectPublic)) {
+                        // If checking for the logo, try all logo variants
+                        if (url.includes('logo')) {
+                            // Try to find ANY logo
+                            for (const asset of ['logo.svg', 'logo.png', 'logo.jpg']) {
+                                const assetPath = path.join(projectPublic, asset);
+                                if (fs.existsSync(assetPath)) {
+                                    const contentType = asset.endsWith('.svg') ? 'image/svg+xml' : (asset.endsWith('.png') ? 'image/png' : 'image/jpeg');
+                                    res.writeHead(200, { 'Content-Type': contentType });
+                                    fs.createReadStream(assetPath).pipe(res);
+                                    return;
+                                }
+                            }
+                        }
+                        // If specific file requested (and not handled by above generic logo logic, or if we want exact match)
+                        const exactPath = path.join(projectPublic, requestedFile);
+                        if (fs.existsSync(exactPath)) {
+                            const contentType = requestedFile.endsWith('.svg') ? 'image/svg+xml' : (requestedFile.endsWith('.png') ? 'image/png' : (requestedFile.endsWith('.ico') ? 'image/x-icon' : 'image/jpeg'));
+                            res.writeHead(200, { 'Content-Type': contentType });
+                            fs.createReadStream(exactPath).pipe(res);
+                            return;
+                        }
+                    }
+                    // 2. Fallback to Taskforce Default Assets (in package)
+                    // Determine where we are running from
+                    let assetPath = '';
+                    // Case 1: Development - look in new src/assets structure
+                    const devAssets = path.resolve(__dirname, '../../src/assets');
+                    // Case 2: Production (dist/plugins/vite.js) -> ../public
+                    const prodPublic = path.resolve(__dirname, '../public');
+                    // Map requested file to our available defaults
+                    // We only have favicon.png and logo.svg in our defaults
+                    let defaultFile = requestedFile;
+                    if (requestedFile.includes('logo') && !requestedFile.endsWith('.svg'))
+                        defaultFile = 'logo.svg';
+                    // If they asked for logo.png/jpg but we only have logo.svg default, serve logo.svg? 
+                    // Browsers might complain about mime type mismatch if we serve svg for png request.
+                    // Better to just serve what we have if it matches name.
+                    if (defaultFile === 'logo.png' || defaultFile === 'logo.jpg')
+                        defaultFile = 'logo.svg'; // Force svg for default logo
+                    if (fs.existsSync(path.join(prodPublic, defaultFile))) {
+                        assetPath = path.join(prodPublic, defaultFile);
+                    }
+                    else if (devAssets) {
+                        // Check image and favicon folders in dev
+                        const imgPath = path.join(devAssets, 'images', defaultFile);
+                        const favPath = path.join(devAssets, 'favicon', defaultFile);
+                        if (fs.existsSync(imgPath)) {
+                            assetPath = imgPath;
+                        }
+                        else if (fs.existsSync(favPath)) {
+                            assetPath = favPath;
+                        }
+                    }
+                    if (assetPath && fs.existsSync(assetPath)) {
+                        // Ensure we send correct content-type for the file we are actually serving
+                        const contentType = assetPath.endsWith('.svg') ? 'image/svg+xml' : 'image/png';
+                        res.writeHead(200, { 'Content-Type': contentType });
+                        fs.createReadStream(assetPath).pipe(res);
+                        return;
+                    }
+                }
+                next();
+            });
+            // 2. Serve standalone UI dashboard (high priority to avoid SPA catch-all)
+            server.middlewares.use(async (req, res, next) => {
+                // Parse URL to handle query params and trailing slashes
+                const urlObj = new URL(req.url || '', 'http://localhost');
+                const pathname = urlObj.pathname;
+                if (pathname === '/taskforce' || pathname === '/taskforce/') {
+                    const html = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" type="image/png" href="/src/assets/favicon/favicon.png" />
+    <title>Taskforce Dashboard</title>
+    <style>
+        body { margin: 0; background: #0f0f1a; color: white; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; }
+        #root { height: 100vh; overflow: hidden; }
+    </style>
+</head>
+<body>
+    <div id="root"></div>
+    <script type="module">
+        import React from 'react';
+        import ReactDOM from 'react-dom/client';
+        import { BrowserRouter } from 'react-router-dom';
+        import { TaskforceCore } from '@taskforcehq/taskforce';
+        
+        const root = document.getElementById('root');
+        ReactDOM.createRoot(root).render(
+            React.createElement(React.StrictMode, null,
+                React.createElement(BrowserRouter, null,
+                    React.createElement(TaskforceCore, {
+                        mode: 'standalone',
+                        config: {
+                            categories: ['Feature', 'Bug', 'Research'],
+                            theme: 'midnight'
+                        }
+                    })
+                )
+            )
+        );
+    </script>
+</body>
+</html>`;
+                    try {
+                        const transformedHtml = await server.transformIndexHtml(req.url || '', html);
+                        res.writeHead(200, { 'Content-Type': 'text/html' });
+                        res.end(transformedHtml);
+                        return;
+                    }
+                    catch (e) {
+                        console.error('[Taskforce] Error rendering standalone page:', e);
+                        res.writeHead(500);
+                        res.end('Error rendering Taskforce dashboard');
+                        return;
+                    }
+                }
+                next();
+            });
+            // 3. Register centralized API routes
+            const objectStorage = resolveObjectStorageConfigFromEnv(process.env);
+            const routes = createRoutes(core, {
+                objectStorage
+            });
+            // Use a single middleware to match all API routes
+            server.middlewares.use(async (req, res, next) => {
+                const url = new URL(req.url || '/', `http://localhost`);
+                const match = matchRoute(req.method || 'GET', url.pathname, routes);
+                if (match) {
+                    try {
+                        // Pass request context (like mode) via headers or req decoration if needed
+                        // Ideally core logic is decoupled from request, but updateConfig reads paths again.
+                        // We can decorate req for routes that need it.
+                        res.req = req;
+                        if (!req.headers['x-taskforce-mode']) {
+                            req.headers['x-taskforce-mode'] = mode; // Inject mode for /config route
+                        }
+                        await match.handler(req, res, match.params);
+                    }
+                    catch (error) {
+                        console.error('[Taskforce] API error:', error);
+                        // Only send error response if headers haven't been sent
+                        if (!res.headersSent) {
+                            const statusCode = Number.isFinite(Number(error?.statusCode))
+                                ? Math.max(400, Math.min(599, Number(error.statusCode)))
+                                : 500;
+                            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: error.message }));
+                        }
+                    }
+                    return;
+                }
+                next();
+            });
+        },
+    };
+}
+export default taskforcePlugin;

package/dist/public/site.webmanifest

@@ -0,0 +1 @@
+{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}

package/dist/resources/templates/WORKFLOW_V2_POLICY.md

@@ -0,0 +1,55 @@
+# Taskforce Workflow v2 Policy
+
+This note defines the canonical policy for v2 workflow templates and environment exports.
+
+## 1) Dispatch Precedence
+- Explicit slash command invocation wins over task `approach`.
+- `/do` may route by `approach` when no conflicting explicit command is provided.
+- `approachMap` should exist as a global default, with optional per-workflow override.
+
+## 2) Required Tools Policy
+- Use hybrid enforcement:
+  - Critical tools: `strict-fail`
+  - Non-critical tools: `warn-and-fallback`
+- Define tools in `compat` as:
+  - `requiredToolsCritical`
+  - `requiredToolsOptional`
+- Fallback behavior must be explicit in workflow content:
+  - Mutating workflows (`do`, `plan`) should stop and ask user when MCP is unavailable.
+  - Non-mutating workflows (`evaluate`, optionally `review`) may continue read-only with clear warning.
+
+## 3) Status Transition Policy
+- AI-managed statuses (default allowed): `task`, `on-hold`, `in-progress`, `review`.
+- AI must not set `done` or `cancelled` unless the user explicitly instructs it.
+- If AI moves status to `task` or `on-hold`, it must add comment justification via MCP.
+- Structured workflow summary comments are validated at MCP `add_comment` time when known summary headings are used.
+
+## 4) Compatibility Policy
+- `compat.minTaskforceVersion` uses semver-aware comparisons.
+- Workflow execution should fail fast if critical compatibility checks are not met.
+
+## 5) MCP Availability Policy
+- `contextPolicy.mcpUnavailableAction` is required.
+- Recommended defaults:
+  - `do`, `plan`: `stop-and-request-user-action`
+  - `evaluate`, `review`: may allow warning-based read-only fallback (project policy dependent)
+
+## 6) Artifact Path Policy
+- Artifact paths must be project-root-relative.
+- Do not write artifacts outside the project root by default.
+- Optional artifacts should use `savePolicy: ask-before-save`.
+- Structured docs saved under `.taskforce/task-data/{taskId}/*` should include required section headings; attachment is validated at MCP attach time.
+
+## 7) Artifact Ownership
+- Keep artifacts owned by the workflow that produces them:
+  - `plan` -> `implementationPlan`
+  - `execute` -> `walkthrough`
+  - `evaluate` -> `evaluationReport` (optional)
+  - `review` -> `reviewReport` (optional)
+
+## 8) Template Maintenance Rule
+- Keep workflow `toolPolicy`, `compat`, `dispatch`, and `contextPolicy` concise and machine-readable.
+- Put explanatory operational details in `content.default`.
+- Edit source definitions in `src/resources/templates/workflow-sources/workflowDocs.mjs`.
+- Use `npm run gen:workflows` after edits to regenerate flattened workflow YAML files.
+- Use `npm run check:workflows` to detect drift between source and generated files.

package/dist/resources/templates/environments/aider.yaml

@@ -0,0 +1,14 @@
+
+id: aider
+name: Aider
+icon: Zap
+workflows:
+  directory: .
+  format: markdown
+  filenamePattern: ".aider/commands/{name}.md"
+  overrides:
+    do:
+      filename: CONVENTIONS.md
+      strategy: inject
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/environments/antigravity.yaml

@@ -0,0 +1,10 @@
+
+id: antigravity
+name: Antigravity
+icon: Bot
+workflows:
+  directory: .agent/workflows
+  format: markdown
+  filenamePattern: "{name}.md"
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/environments/claude.yaml

@@ -0,0 +1,10 @@
+
+id: claude
+name: Claude Desktop
+icon: Terminal
+workflows:
+  directory: .claude/commands
+  format: markdown
+  filenamePattern: "{name}.md"
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/environments/cline.yaml

@@ -0,0 +1,10 @@
+
+id: cline
+name: Cline
+icon: Box
+workflows:
+  directory: .clinerules
+  format: markdown
+  filenamePattern: "{name}.md"
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/environments/codex.yaml

@@ -0,0 +1,13 @@
+id: codex
+name: Codex
+icon: Terminal
+workflows:
+  directory: .
+  format: markdown
+  filenamePattern: ".codex/workflows/{name}.md"
+  overrides:
+    do:
+      filename: AGENTS.md
+      strategy: inject
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/environments/copilot.yaml

@@ -0,0 +1,10 @@
+
+id: copilot
+name: GitHub Copilot
+icon: Github
+workflows:
+  directory: .github/prompts
+  format: markdown
+  filenamePattern: "{name}.prompt.md"
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/environments/cursor.yaml

@@ -0,0 +1,9 @@
+
+id: cursor
+name: Cursor AI
+workflows:
+  directory: .cursor/rules
+  format: mdc
+  filenamePattern: "{name}.mdc"
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/environments/gemini.yaml

@@ -0,0 +1,9 @@
+
+id: gemini
+name: Gemini CLI
+workflows:
+  directory: .gemini/commands
+  format: toml
+  filenamePattern: "{name}.toml"
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/environments/windsurf.yaml

@@ -0,0 +1,10 @@
+
+id: windsurf
+name: Windsurf
+icon: Wind
+workflows:
+  directory: .windsurf/rules
+  format: mdc
+  filenamePattern: "{name}.mdc"
+mcp:
+  prefix: "mcp_taskforce-{projectName}_"

package/dist/resources/templates/workflow-sources/README.md

@@ -0,0 +1,9 @@
+# Workflow Template Sources
+
+This directory is the source of truth for workflow template definitions.
+
+- Edit `workflowDocs.mjs` to change workflow structure/content.
+- Run `npm run gen:workflows` to regenerate flattened YAML files in `../workflows`.
+- Use `npm run check:workflows` to verify generated files are up to date.
+
+Do not manually edit files in `../workflows` unless you immediately regenerate from source.