opencode-hive 0.4.2 → 0.5.0

package/dist/index.js

@@ -4,19 +4,24 @@ import { WorktreeService } from "./services/worktreeService.js";
 import { FeatureService } from "./services/featureService.js";
 import { PlanService } from "./services/planService.js";
 import { TaskService } from "./services/taskService.js";
+import { ContextService } from "./services/contextService.js";
+import { SessionService } from "./services/sessionService.js";
+import { detectContext, listFeatures } from "./utils/detection.js";
 const HIVE_SYSTEM_PROMPT = `
 ## Hive - Feature Development System
 
 Plan-first development: Write plan → User reviews → Approve → Execute tasks
 
-### Tools (13 total)
+### Tools (16 total)
 
 | Domain | Tools |
 |--------|-------|
-| Feature | hive_feature_create, hive_feature_list, hive_feature_switch, hive_feature_complete, hive_status |
+| Feature | hive_feature_create, hive_feature_list, hive_feature_complete |
 | Plan | hive_plan_write, hive_plan_read, hive_plan_approve |
 | Task | hive_tasks_sync, hive_task_create, hive_task_update |
 | Exec | hive_exec_start, hive_exec_complete, hive_exec_abort |
+| Context | hive_context_write, hive_context_read, hive_context_list |
+| Session | hive_session_open, hive_session_list |
 
 ### Workflow
 
@@ -44,6 +49,19 @@ Description of what to do.
 Description.
 \`\`\`
 
+### Planning Phase - Context Management REQUIRED
+
+As you research and plan, CONTINUOUSLY save findings using \`hive_context_write\`:
+- Research findings (API patterns, library docs, codebase structure)
+- User preferences ("we use Zustand, not Redux")
+- Rejected alternatives ("tried X, too complex")
+- Architecture decisions ("auth lives in /lib/auth")
+
+**Update existing context files** when new info emerges - dont create duplicates.
+Workers depend on context for background. Without it, they work blind.
+
+Save context BEFORE writing the plan, and UPDATE it as planning iterates.
+
 \`hive_tasks_sync\` parses \`### N. Task Name\` headers.
 `;
 const plugin = async (ctx) => {
@@ -51,26 +69,36 @@ const plugin = async (ctx) => {
     const featureService = new FeatureService(directory);
     const planService = new PlanService(directory);
     const taskService = new TaskService(directory);
+    const contextService = new ContextService(directory);
+    const sessionService = new SessionService(directory);
     const worktreeService = new WorktreeService({
         baseDir: directory,
         hiveDir: path.join(directory, '.hive'),
     });
-    const captureSession = (toolContext) => {
-        const activeFeature = featureService.getActive();
-        if (!activeFeature)
-            return;
+    const resolveFeature = (explicit) => {
+        if (explicit)
+            return explicit;
+        const context = detectContext(directory);
+        if (context.feature)
+            return context.feature;
+        const features = listFeatures(directory);
+        if (features.length === 1)
+            return features[0];
+        return null;
+    };
+    const captureSession = (feature, toolContext) => {
         const ctx = toolContext;
         if (ctx?.sessionID) {
-            const currentSession = featureService.getSession(activeFeature);
+            const currentSession = featureService.getSession(feature);
             if (currentSession !== ctx.sessionID) {
-                featureService.setSession(activeFeature, ctx.sessionID);
+                featureService.setSession(feature, ctx.sessionID);
             }
         }
     };
     return {
         "experimental.chat.system.transform": async (_input, output) => {
             output.system.push(HIVE_SYSTEM_PROMPT);
-            const activeFeature = featureService.getActive();
+            const activeFeature = resolveFeature();
             if (activeFeature) {
                 const info = featureService.getInfo(activeFeature);
                 if (info) {
@@ -101,7 +129,7 @@ const plugin = async (ctx) => {
                 args: {},
                 async execute() {
                     const features = featureService.list();
-                    const active = featureService.getActive();
+                    const active = resolveFeature();
                     if (features.length === 0)
                         return "No features found.";
                     const list = features.map(f => {
@@ -111,58 +139,42 @@ const plugin = async (ctx) => {
                     return list.join('\n');
                 },
             }),
-            hive_feature_switch: tool({
-                description: 'Switch to a different feature',
-                args: { name: tool.schema.string().describe('Feature name') },
-                async execute({ name }) {
-                    featureService.setActive(name);
-                    return `Switched to feature "${name}"`;
-                },
-            }),
             hive_feature_complete: tool({
                 description: 'Mark feature as completed (irreversible)',
                 args: { name: tool.schema.string().optional().describe('Feature name (defaults to active)') },
                 async execute({ name }) {
-                    const feature = name || featureService.getActive();
+                    const feature = resolveFeature(name);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide name.";
                     featureService.complete(feature);
                     return `Feature "${feature}" marked as completed`;
                 },
             }),
-            hive_status: tool({
-                description: 'Get overview of active feature',
-                args: { name: tool.schema.string().optional().describe('Feature name (defaults to active)') },
-                async execute({ name }) {
-                    const feature = name || featureService.getActive();
-                    if (!feature)
-                        return "Error: No active feature";
-                    const info = featureService.getInfo(feature);
-                    if (!info)
-                        return `Error: Feature "${feature}" not found`;
-                    return JSON.stringify(info, null, 2);
-                },
-            }),
             hive_plan_write: tool({
                 description: 'Write plan.md (clears existing comments)',
-                args: { content: tool.schema.string().describe('Plan markdown content') },
-                async execute({ content }, toolContext) {
-                    captureSession(toolContext);
-                    const feature = featureService.getActive();
+                args: {
+                    content: tool.schema.string().describe('Plan markdown content'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
+                },
+                async execute({ content, feature: explicitFeature }, toolContext) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    captureSession(feature, toolContext);
                     const planPath = planService.write(feature, content);
                     return `Plan written to ${planPath}. Comments cleared for fresh review.`;
                 },
             }),
             hive_plan_read: tool({
                 description: 'Read plan.md and user comments',
-                args: {},
-                async execute(_args, toolContext) {
-                    captureSession(toolContext);
-                    const feature = featureService.getActive();
+                args: {
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
+                },
+                async execute({ feature: explicitFeature }, toolContext) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    captureSession(feature, toolContext);
                     const result = planService.read(feature);
                     if (!result)
                         return "Error: No plan.md found";
@@ -171,12 +183,14 @@ const plugin = async (ctx) => {
             }),
             hive_plan_approve: tool({
                 description: 'Approve plan for execution',
-                args: {},
-                async execute(_args, toolContext) {
-                    captureSession(toolContext);
-                    const feature = featureService.getActive();
+                args: {
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
+                },
+                async execute({ feature: explicitFeature }, toolContext) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    captureSession(feature, toolContext);
                     const comments = planService.getComments(feature);
                     if (comments.length > 0) {
                         return `Error: Cannot approve - ${comments.length} unresolved comment(s). Address them first.`;
@@ -187,11 +201,13 @@ const plugin = async (ctx) => {
             }),
             hive_tasks_sync: tool({
                 description: 'Generate tasks from approved plan',
-                args: {},
-                async execute() {
-                    const feature = featureService.getActive();
+                args: {
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
+                },
+                async execute({ feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
                     const featureData = featureService.get(feature);
                     if (!featureData || featureData.status === 'planning') {
                         return "Error: Plan must be approved first";
@@ -208,11 +224,12 @@ const plugin = async (ctx) => {
                 args: {
                     name: tool.schema.string().describe('Task name'),
                     order: tool.schema.number().optional().describe('Task order'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
                 },
-                async execute({ name, order }) {
-                    const feature = featureService.getActive();
+                async execute({ name, order, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
                     const folder = taskService.create(feature, name, order);
                     return `Manual task created: ${folder}`;
                 },
@@ -223,11 +240,12 @@ const plugin = async (ctx) => {
                     task: tool.schema.string().describe('Task folder name'),
                     status: tool.schema.string().optional().describe('New status: pending, in_progress, done, cancelled'),
                     summary: tool.schema.string().optional().describe('Summary of work'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
                 },
-                async execute({ task, status, summary }) {
-                    const feature = featureService.getActive();
+                async execute({ task, status, summary, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
                     const updated = taskService.update(feature, task, {
                         status: status,
                         summary,
@@ -237,19 +255,47 @@ const plugin = async (ctx) => {
             }),
             hive_exec_start: tool({
                 description: 'Create worktree and begin work on task',
-                args: { task: tool.schema.string().describe('Task folder name') },
-                async execute({ task }) {
-                    const feature = featureService.getActive();
+                args: {
+                    task: tool.schema.string().describe('Task folder name'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
+                },
+                async execute({ task, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
                     const taskInfo = taskService.get(feature, task);
                     if (!taskInfo)
                         return `Error: Task "${task}" not found`;
                     if (taskInfo.status === 'done')
                         return "Error: Task already completed";
                     const worktree = await worktreeService.create(feature, task);
-                    taskService.update(feature, task, { status: 'in_progress' });
-                    return `Worktree created at ${worktree.path}\nBranch: ${worktree.branch}`;
+                    taskService.update(feature, task, {
+                        status: 'in_progress',
+                        baseCommit: worktree.commit,
+                    });
+                    // Generate spec.md with context for task
+                    const planResult = planService.read(feature);
+                    const contextCompiled = contextService.compile(feature);
+                    const allTasks = taskService.list(feature);
+                    const priorTasks = allTasks
+                        .filter(t => t.status === 'done')
+                        .map(t => `- ${t.folder}: ${t.summary || 'No summary'}`);
+                    let specContent = `# Task: ${task}\n\n`;
+                    specContent += `## Feature: ${feature}\n\n`;
+                    if (planResult) {
+                        const taskMatch = planResult.content.match(new RegExp(`###\\s*\\d+\\.\\s*${taskInfo.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[\\s\\S]*?(?=###|$)`, 'i'));
+                        if (taskMatch) {
+                            specContent += `## Plan Section\n\n${taskMatch[0].trim()}\n\n`;
+                        }
+                    }
+                    if (contextCompiled) {
+                        specContent += `## Context\n\n${contextCompiled}\n\n`;
+                    }
+                    if (priorTasks.length > 0) {
+                        specContent += `## Completed Tasks\n\n${priorTasks.join('\n')}\n\n`;
+                    }
+                    taskService.writeSpec(feature, task, specContent);
+                    return `Worktree created at ${worktree.path}\nBranch: ${worktree.branch}\nBase commit: ${worktree.commit}\nSpec: ${task}/spec.md generated`;
                 },
             }),
             hive_exec_complete: tool({
@@ -257,39 +303,191 @@ const plugin = async (ctx) => {
                 args: {
                     task: tool.schema.string().describe('Task folder name'),
                     summary: tool.schema.string().describe('Summary of what was done'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
                 },
-                async execute({ task, summary }) {
-                    const feature = featureService.getActive();
+                async execute({ task, summary, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
                     const taskInfo = taskService.get(feature, task);
                     if (!taskInfo)
                         return `Error: Task "${task}" not found`;
                     if (taskInfo.status !== 'in_progress')
                         return "Error: Task not in progress";
                     const diff = await worktreeService.getDiff(feature, task);
+                    let changesApplied = false;
+                    let applyError = "";
                     if (diff?.hasDiff) {
-                        await worktreeService.applyDiff(feature, task);
+                        const result = await worktreeService.applyDiff(feature, task);
+                        changesApplied = result.success;
+                        if (!result.success) {
+                            applyError = result.error || "Unknown apply error";
+                        }
+                    }
+                    const reportLines = [
+                        `# Task Report: ${task}`,
+                        '',
+                        `**Feature:** ${feature}`,
+                        `**Completed:** ${new Date().toISOString()}`,
+                        `**Status:** ${applyError ? 'completed with errors' : 'success'}`,
+                        '',
+                        '---',
+                        '',
+                        '## Summary',
+                        '',
+                        summary,
+                        '',
+                    ];
+                    if (diff?.hasDiff) {
+                        reportLines.push('---', '', '## Changes', '', `- **Files changed:** ${diff.filesChanged.length}`, `- **Insertions:** +${diff.insertions}`, `- **Deletions:** -${diff.deletions}`, '');
+                        if (diff.filesChanged.length > 0) {
+                            reportLines.push('### Files Modified', '');
+                            for (const file of diff.filesChanged) {
+                                reportLines.push(`- \`${file}\``);
+                            }
+                            reportLines.push('');
+                        }
+                    }
+                    else {
+                        reportLines.push('---', '', '## Changes', '', '_No file changes detected_', '');
                     }
-                    const report = `# ${task}\n\n## Summary\n\n${summary}\n`;
-                    taskService.writeReport(feature, task, report);
+                    taskService.writeReport(feature, task, reportLines.join('\n'));
                     taskService.update(feature, task, { status: 'done', summary });
                     await worktreeService.remove(feature, task);
-                    return `Task "${task}" completed. Changes applied.`;
+                    if (applyError) {
+                        return `Task "${task}" completed but changes failed to apply: ${applyError}`;
+                    }
+                    return `Task "${task}" completed.${changesApplied ? " Changes applied." : ""}`;
                 },
             }),
             hive_exec_abort: tool({
                 description: 'Abort task: discard changes, reset status',
-                args: { task: tool.schema.string().describe('Task folder name') },
-                async execute({ task }) {
-                    const feature = featureService.getActive();
+                args: {
+                    task: tool.schema.string().describe('Task folder name'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to detection or single feature)'),
+                },
+                async execute({ task, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
                     if (!feature)
-                        return "Error: No active feature";
+                        return "Error: No feature specified. Create a feature or provide feature param.";
                     await worktreeService.remove(feature, task);
                     taskService.update(feature, task, { status: 'pending' });
                     return `Task "${task}" aborted. Status reset to pending.`;
                 },
             }),
+            // Context Tools
+            hive_context_write: tool({
+                description: 'Write a context file for the feature. Context files store persistent notes, decisions, and reference material.',
+                args: {
+                    name: tool.schema.string().describe('Context file name (e.g., "decisions", "architecture", "notes")'),
+                    content: tool.schema.string().describe('Markdown content to write'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ name, content, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    const filePath = contextService.write(feature, name, content);
+                    return `Context file written: ${filePath}`;
+                },
+            }),
+            hive_context_read: tool({
+                description: 'Read a specific context file or all context for the feature',
+                args: {
+                    name: tool.schema.string().optional().describe('Context file name. If omitted, returns all context compiled.'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ name, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    if (name) {
+                        const content = contextService.read(feature, name);
+                        if (!content)
+                            return `Error: Context file '${name}' not found`;
+                        return content;
+                    }
+                    const compiled = contextService.compile(feature);
+                    if (!compiled)
+                        return "No context files found";
+                    return compiled;
+                },
+            }),
+            hive_context_list: tool({
+                description: 'List all context files for the feature',
+                args: {
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    const files = contextService.list(feature);
+                    if (files.length === 0)
+                        return "No context files";
+                    return files.map(f => `${f.name} (${f.content.length} chars, updated ${f.updatedAt})`).join('\n');
+                },
+            }),
+            // Session Tools
+            hive_session_open: tool({
+                description: 'Open session, return full context for a feature',
+                args: {
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                    task: tool.schema.string().optional().describe('Task folder to focus on'),
+                },
+                async execute({ feature: explicitFeature, task }, toolContext) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    const featureData = featureService.get(feature);
+                    if (!featureData)
+                        return `Error: Feature '${feature}' not found`;
+                    // Track session
+                    const ctx = toolContext;
+                    if (ctx?.sessionID) {
+                        sessionService.track(feature, ctx.sessionID, task);
+                    }
+                    const planResult = planService.read(feature);
+                    const tasks = taskService.list(feature);
+                    const contextCompiled = contextService.compile(feature);
+                    const sessions = sessionService.list(feature);
+                    let output = `## Feature: ${feature} [${featureData.status}]\n\n`;
+                    if (planResult) {
+                        output += `### Plan\n${planResult.content.substring(0, 500)}...\n\n`;
+                    }
+                    output += `### Tasks (${tasks.length})\n`;
+                    tasks.forEach(t => {
+                        output += `- ${t.folder}: ${t.name} [${t.status}]\n`;
+                    });
+                    if (contextCompiled) {
+                        output += `\n### Context\n${contextCompiled.substring(0, 500)}...\n`;
+                    }
+                    output += `\n### Sessions (${sessions.length})\n`;
+                    sessions.forEach(s => {
+                        output += `- ${s.sessionId} (${s.taskFolder || 'no task'})\n`;
+                    });
+                    return output;
+                },
+            }),
+            hive_session_list: tool({
+                description: 'List all sessions for the feature',
+                args: {
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    const sessions = sessionService.list(feature);
+                    const master = sessionService.getMaster(feature);
+                    if (sessions.length === 0)
+                        return "No sessions";
+                    return sessions.map(s => {
+                        const masterMark = s.sessionId === master ? ' (master)' : '';
+                        return `${s.sessionId}${masterMark} - ${s.taskFolder || 'no task'} - ${s.lastActiveAt}`;
+                    }).join('\n');
+                },
+            }),
         },
         command: {
             hive: {

package/dist/services/contextService.d.ts

@@ -0,0 +1,15 @@
+export interface ContextFile {
+    name: string;
+    content: string;
+    updatedAt: string;
+}
+export declare class ContextService {
+    private projectRoot;
+    constructor(projectRoot: string);
+    write(featureName: string, fileName: string, content: string): string;
+    read(featureName: string, fileName: string): string | null;
+    list(featureName: string): ContextFile[];
+    delete(featureName: string, fileName: string): boolean;
+    compile(featureName: string): string;
+    private normalizeFileName;
+}

package/dist/services/contextService.js

@@ -0,0 +1,59 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getContextPath, ensureDir, fileExists, readText, writeText } from '../utils/paths.js';
+export class ContextService {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    write(featureName, fileName, content) {
+        const contextPath = getContextPath(this.projectRoot, featureName);
+        ensureDir(contextPath);
+        const filePath = path.join(contextPath, this.normalizeFileName(fileName));
+        writeText(filePath, content);
+        return filePath;
+    }
+    read(featureName, fileName) {
+        const contextPath = getContextPath(this.projectRoot, featureName);
+        const filePath = path.join(contextPath, this.normalizeFileName(fileName));
+        return readText(filePath);
+    }
+    list(featureName) {
+        const contextPath = getContextPath(this.projectRoot, featureName);
+        if (!fileExists(contextPath))
+            return [];
+        const files = fs.readdirSync(contextPath, { withFileTypes: true })
+            .filter(f => f.isFile() && f.name.endsWith('.md'))
+            .map(f => f.name);
+        return files.map(name => {
+            const filePath = path.join(contextPath, name);
+            const stat = fs.statSync(filePath);
+            const content = readText(filePath) || '';
+            return {
+                name: name.replace(/\.md$/, ''),
+                content,
+                updatedAt: stat.mtime.toISOString(),
+            };
+        });
+    }
+    delete(featureName, fileName) {
+        const contextPath = getContextPath(this.projectRoot, featureName);
+        const filePath = path.join(contextPath, this.normalizeFileName(fileName));
+        if (fileExists(filePath)) {
+            fs.unlinkSync(filePath);
+            return true;
+        }
+        return false;
+    }
+    compile(featureName) {
+        const files = this.list(featureName);
+        if (files.length === 0)
+            return '';
+        const sections = files.map(f => `## ${f.name}\n\n${f.content}`);
+        return sections.join('\n\n---\n\n');
+    }
+    normalizeFileName(name) {
+        const normalized = name.replace(/\.md$/, '');
+        return `${normalized}.md`;
+    }
+}

package/dist/services/featureService.d.ts

@@ -5,8 +5,6 @@ export declare class FeatureService {
     create(name: string, ticket?: string): FeatureJson;
     get(name: string): FeatureJson | null;
     list(): string[];
-    getActive(): string | null;
-    setActive(name: string): void;
     updateStatus(name: string, status: FeatureStatusType): FeatureJson;
     getInfo(name: string): FeatureInfo | null;
     private getTasks;

package/dist/services/featureService.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs';
-import { getFeaturePath, getFeaturesPath, getFeatureJsonPath, getContextPath, getTasksPath, getActiveFeaturePath, getPlanPath, getCommentsPath, ensureDir, readJson, writeJson, readText, writeText, fileExists, } from '../utils/paths.js';
+import { getFeaturePath, getFeaturesPath, getFeatureJsonPath, getContextPath, getTasksPath, getPlanPath, getCommentsPath, ensureDir, readJson, writeJson, fileExists, } from '../utils/paths.js';
 export class FeatureService {
     projectRoot;
     constructor(projectRoot) {
@@ -20,7 +20,6 @@ export class FeatureService {
             createdAt: new Date().toISOString(),
         };
         writeJson(getFeatureJsonPath(this.projectRoot, name), feature);
-        this.setActive(name);
         return feature;
     }
     get(name) {
@@ -34,15 +33,6 @@ export class FeatureService {
             .filter(d => d.isDirectory())
             .map(d => d.name);
     }
-    getActive() {
-        return readText(getActiveFeaturePath(this.projectRoot))?.trim() || null;
-    }
-    setActive(name) {
-        const feature = this.get(name);
-        if (!feature)
-            throw new Error(`Feature '${name}' not found`);
-        writeText(getActiveFeaturePath(this.projectRoot), name);
-    }
     updateStatus(name, status) {
         const feature = this.get(name);
         if (!feature)

package/dist/services/featureService.test.d.ts

@@ -0,0 +1 @@
+export {};