feat: Mode system with inheritance and multilingual support (#412)
* feat: add domain management system with support for multiple domain profiles
- Introduced DomainManager class for loading and managing domain profiles.
- Added support for a default domain ('code') and fallback mechanisms.
- Implemented domain configuration validation and error handling.
- Created types for domain configuration, observation types, and concepts.
- Added new directory for domain profiles and ensured its existence.
- Updated SettingsDefaultsManager to include CLAUDE_MEM_DOMAIN setting.
* Refactor domain management to mode management
- Removed DomainManager class and replaced it with ModeManager for better clarity and functionality.
- Updated types from DomainConfig to ModeConfig and DomainPrompts to ModePrompts.
- Changed references from domains to modes in the settings and paths.
- Ensured backward compatibility by maintaining the fallback mechanism to the 'code' mode.
* feat: add migration 008 to support mode-agnostic observations and refactor service layer references in documentation
* feat: add new modes for code development and email investigation with detailed observation types and concepts
* Refactor observation parsing and prompt generation to incorporate mode-specific configurations
- Updated `parseObservations` function to use 'observation' as a universal fallback type instead of 'change', utilizing active mode's valid observation types.
- Modified `buildInitPrompt` and `buildContinuationPrompt` functions to accept a `ModeConfig` parameter, allowing for dynamic prompt content based on the active mode.
- Enhanced `ModePrompts` interface to include additional guidance for observers, such as recording focus and skip guidance.
- Adjusted the SDKAgent to load the active mode and pass it to prompt generation functions, ensuring prompts are tailored to the current mode's context.
* fix: correct mode prompt injection to preserve exact wording and type list visibility
- Add script to extract prompts from main branch prompts.ts into code.yaml
- Fix prompts.ts to show type list in XML template (e.g., "[ bugfix | feature | ... ]")
- Keep 'change' as fallback type in parser.ts (maintain backwards compatibility)
- Regenerate code.yaml with exact wording from original hardcoded prompts
- Build succeeds with no TypeScript errors
* fix: update ModeManager to load JSON mode files and improve validation
- Changed ModeManager to load mode configurations from JSON files instead of YAML.
- Removed the requirement for an "observation" type and updated validation to require at least one observation type.
- Updated fallback behavior in the parser to use the first type from the active mode's type list.
- Added comprehensive tests for mode loading, prompt injection, and parser integration, ensuring correct behavior across different modes.
- Introduced new mode JSON files for "Code Development" and "Email Investigation" with detailed observation types and prompts.
* Add mode configuration loading and update licensing information for Ragtime
- Implemented loading of mode configuration in WorkerService before database initialization.
- Added PolyForm Noncommercial License 1.0.0 to Ragtime directory.
- Created README.md for Ragtime with licensing details and usage guidelines.
* fix: add datasets directory to .gitignore to prevent accidental commits
* refactor: remove unused plugin package.json file
* chore: add package.json for claude-mem plugin with version 7.4.5
* refactor: remove outdated tests and improve error handling
- Deleted tests for ChromaSync error handling, smart install, strip memory tags, and user prompt tag stripping due to redundancy or outdated logic.
- Removed vitest configuration as it is no longer needed.
- Added a comprehensive implementation plan for fixing the modes system, addressing critical issues and improving functionality.
- Created a detailed test analysis report highlighting the quality and effectiveness of the current test suite, identifying areas for improvement.
- Introduced a new plugin package.json for runtime dependencies related to claude-mem hooks.
* refactor: remove parser regression tests to streamline codebase
* docs: update CLAUDE.md to clarify test management and changelog generation
* refactor: remove migration008 for mode-agnostic observations
* Refactor observation type handling to use ModeManager for icons and emojis
- Removed direct mappings of observation types to icons and work emojis in context-generator, FormattingService, SearchManager, and TimelineService.
- Integrated ModeManager to dynamically retrieve icons and emojis based on the active mode.
- Improved maintainability by centralizing the logic for observation type representation.
* Refactor observation metadata constants and update context generator
- Removed the explicit declaration of OBSERVATION_TYPES and OBSERVATION_CONCEPTS from observation-metadata.ts.
- Introduced fallback default strings for DEFAULT_OBSERVATION_TYPES_STRING and DEFAULT_OBSERVATION_CONCEPTS_STRING.
- Updated context-generator.ts to utilize observation types and concepts from ModeManager instead of constants.
* refactor: remove intermediate error handling from hooks (Phase 1)
Apply "fail fast" error handling strategy - errors propagate and crash loud
instead of being caught, wrapped, and re-thrown at intermediate layers.
Changes:
- Remove try/catch around fetch calls in all hooks - let errors throw
- Add try/catch ONLY around JSON.parse at entry points
- Delete error-handler.ts and hook-error-handler.ts (no longer needed)
- Update worker-utils.ts: functions now throw instead of returning null
- Update transcript-parser.ts: throw on missing path, empty file, malformed JSON
- Remove all handleWorkerError, handleFetchError imports
Philosophy: If something breaks, we KNOW it broke. No silent failures.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* refactor: remove intermediate error handling from worker service (Phase 2)
Apply "fail fast" error handling strategy to worker service layer.
Changes:
- worker-service.ts: Remove try/catch from version endpoint, cleanup,
MCP close, process enumeration, force kill, and isAlive check
- SessionRoutes.ts: Remove try/catch from JSON.stringify calls, remove
.catch() from Chroma sync and SDK agent calls
- SettingsRoutes.ts: Remove try/catch from toggleMcp()
- DatabaseManager.ts: Remove .catch() from backfill and close operations
- SDKAgent.ts: Keep outer try/catch (top-level), remove .catch() from
Chroma sync operations
- SSEBroadcaster.ts: Remove try/catch from broadcast and sendToClient
Philosophy: Errors propagate and crash loud. BaseRouteHandler.wrapHandler
provides top-level catching for HTTP routes.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* refactor: remove error swallowing from SQLite services (Phase 3)
Apply "fail fast" error handling strategy to database layer.
SessionStore.ts migrations:
- ensureWorkerPortColumn(): Remove outer try/catch, let it throw
- ensurePromptTrackingColumns(): Remove outer try/catch, let it throw
- removeSessionSummariesUniqueConstraint(): Keep inner transaction
rollback, remove outer catch
- addObservationHierarchicalFields(): Remove outer try/catch
- makeObservationsTextNullable(): Keep inner transaction rollback,
remove outer catch
- createUserPromptsTable(): Keep inner transaction rollback, remove
outer catch
- getFilesForSession(): Remove try/catch around JSON.parse
SessionSearch.ts:
- ensureFTSTables(): Remove try/catch, let it throw
Philosophy: Migration errors that are swallowed mean we think the
database is fine when it's not. Keep only inner transaction rollback
try/catch blocks.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* refactor: remove error hiding from utilities (Phase 4)
Apply "fail fast" error handling strategy to utility layer.
logger.ts:
- formatTool(): Remove try/catch, let JSON.parse throw on malformed input
context-generator.ts:
- loadContextConfig(): Remove try/catch, let parseInt throw on invalid settings
- Transcript extraction: Remove try/catch, let file read errors propagate
ChromaSync.ts:
- close(): Remove nested try/catch blocks, let close errors propagate
Philosophy: No silent fallbacks or hidden defaults. If something breaks,
we know it broke immediately.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* feat: serve static UI assets and update package root path
- Added middleware to serve static UI assets (JS, CSS, fonts, etc.) in ViewerRoutes.
- Updated getPackageRoot function to correctly return the package root directory as one level up from the current directory.
* feat: Enhance mode loading with inheritance support
- Introduced parseInheritance method to handle parent--override mode IDs.
- Added deepMerge method for recursively merging mode configurations.
- Updated loadMode method to support inheritance, loading parent modes and applying overrides.
- Improved error handling for missing mode files and logging for better traceability.
* fix(modes): correct inheritance file resolution and path handling
* Refactor code structure for improved readability and maintainability
* feat: Add mode configuration documentation and examples
* fix: Improve concurrency handling in translateReadme function
* Refactor SDK prompts to enhance clarity and structure
- Updated the `buildInitPrompt` and `buildContinuationPrompt` functions in `prompts.ts` to improve the organization of prompt components, including the addition of language instructions and footer messages.
- Removed redundant instructions and emphasized the importance of recording observations.
- Modified the `ModePrompts` interface in `types.ts` to include new properties for system identity, language instructions, and output format header, ensuring better flexibility and clarity in prompt generation.
* Enhance prompts with language instructions and XML formatting
- Updated `buildInitPrompt`, `buildSummaryPrompt`, and `buildContinuationPrompt` functions to include detailed language instructions in XML comments.
- Ensured that language instructions guide users to keep XML tags in English while writing content in the specified language.
- Modified the `buildSummaryPrompt` function to accept `mode` as a parameter for consistency.
- Adjusted the call to `buildSummaryPrompt` in `SDKAgent` to pass the `mode` argument.
* Refactor XML prompt generation in SDK
- Updated the buildInitPrompt, buildSummaryPrompt, and buildContinuationPrompt functions to use new placeholders for XML elements, improving maintainability and readability.
- Removed redundant language instructions in comments for clarity.
- Added new properties to ModePrompts interface for better structure and organization of XML placeholders and section headers.
* feat: Update observation prompts and structure across multiple languages
* chore: Remove planning docs and update Ragtime README
Remove ephemeral development artifacts:
- .claude/plans/modes-system-fixes.md
- .claude/test-analysis-report.md
- PROMPT_INJECTION_ANALYSIS.md
Update ragtime/README.md to explain:
- Feature is not yet implemented
- Dependency on modes system (now complete in PR #412)
- Ready to be scripted out in future release
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* fix: Move summary prompts to mode files for multilingual support
Summary prompts were hardcoded in English in prompts.ts, breaking
multilingual support. Now properly mode-based:
- Added summary_instruction, summary_context_label,
summary_format_instruction, summary_footer to code.json
- Updated buildSummaryPrompt() to use mode fields instead of hardcoded text
- Added summary_footer with language instructions to all 10 language modes
- Language modes keep English prompts + language requirement footer
This fixes the gaslighting where we claimed full multilingual support
but summaries were still generated in English.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* chore: Clean up README by removing local preview instructions and streamlining beta features section
* Add translated README files for Ukrainian, Vietnamese, and Chinese languages
* Add new language modes for code development in multiple languages
- Introduced JSON configurations for Code Development in Greek, Finnish, Hebrew, Hindi, Hungarian, Indonesian, Italian, Dutch, Norwegian, Polish, Brazilian Portuguese, Romanian, Swedish, Turkish, and Ukrainian.
- Each configuration includes prompts for observations, summaries, and instructions tailored to the respective language.
- Ensured that all prompts emphasize the importance of generating observations without referencing the agent's actions.
* Add multilingual support links to README files in various languages
- Updated README.id.md, README.it.md, README.ja.md, README.ko.md, README.nl.md, README.no.md, README.pl.md, README.pt-br.md, README.ro.md, README.ru.md, README.sv.md, README.th.md, README.tr.md, README.uk.md, README.vi.md, and README.zh.md to include links to other language versions.
- Each README now features a centered paragraph with flags and links for easy navigation between different language documents.
---------
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Alex Newman
@@ -1,53 +0,0 @@
|
||||
/**
|
||||
* Integration Test: Context Inject Early Access
|
||||
*
|
||||
* Tests that /api/context/inject endpoint is available immediately
|
||||
* when worker starts, even before background initialization completes.
|
||||
*
|
||||
* This prevents the 404 error described in the issue where the hook
|
||||
* tries to access the endpoint before SearchRoutes are registered.
|
||||
*/
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
|
||||
describe('Context Inject Early Access', () => {
|
||||
const workerPath = path.join(__dirname, '../../plugin/scripts/worker-service.cjs');
|
||||
|
||||
it('should have /api/context/inject route available immediately on startup', async () => {
|
||||
// This test verifies the fix by checking that:
|
||||
// 1. The route exists immediately (no 404)
|
||||
// 2. The route waits for initialization before processing
|
||||
// 3. Requests don't fail with "Cannot GET /api/context/inject"
|
||||
|
||||
// The fix adds an early handler that:
|
||||
// - Registers the route in setupRoutes() (called during construction)
|
||||
// - Waits for initializationComplete promise
|
||||
// - Processes the request after initialization
|
||||
|
||||
// Since we can't easily spin up a full worker in tests,
|
||||
// we verify the code structure is correct by checking
|
||||
// the compiled output contains the necessary pieces
|
||||
|
||||
const workerCode = fs.readFileSync(workerPath, 'utf-8');
|
||||
|
||||
// Verify initialization promise exists
|
||||
expect(workerCode).toContain('initializationComplete');
|
||||
expect(workerCode).toContain('resolveInitialization');
|
||||
|
||||
// Verify early route handler is registered in setupRoutes
|
||||
expect(workerCode).toContain('/api/context/inject');
|
||||
expect(workerCode).toContain('Promise.race');
|
||||
|
||||
// Verify the promise is resolved after initialization
|
||||
expect(workerCode).toContain('this.resolveInitialization()');
|
||||
});
|
||||
|
||||
it('should handle timeout if initialization takes too long', () => {
|
||||
const workerCode = fs.readFileSync(workerPath, 'utf-8');
|
||||
|
||||
// Verify timeout protection (30 seconds)
|
||||
expect(workerCode).toContain('3e4'); // 30000 in scientific notation
|
||||
expect(workerCode).toContain('Initialization timeout');
|
||||
});
|
||||
});
|
||||
@@ -1,353 +0,0 @@
|
||||
/**
|
||||
* Integration Test: Full Observation Lifecycle
|
||||
*
|
||||
* Tests the complete flow from tool usage to observation storage
|
||||
* and retrieval through search. This validates that all components
|
||||
* work together correctly.
|
||||
*/
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
||||
import {
|
||||
bashCommandScenario,
|
||||
sessionScenario,
|
||||
sampleObservation
|
||||
} from '../helpers/scenarios.js';
|
||||
import { getWorkerPort } from '../../src/shared/worker-utils.js';
|
||||
|
||||
describe('Full Observation Lifecycle', () => {
|
||||
const WORKER_PORT = getWorkerPort();
|
||||
let sessionId: string;
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
sessionId = sessionScenario.claudeSessionId;
|
||||
});
|
||||
|
||||
it('observation flows from hook to database to search', async () => {
|
||||
/**
|
||||
* This integration test simulates the complete happy path:
|
||||
*
|
||||
* 1. Session starts → Context injected
|
||||
* 2. User types prompt → First tool runs
|
||||
* 3. Tool result captured → Observation queued
|
||||
* 4. SDK processes → Observation saved
|
||||
* 5. Search finds observation
|
||||
* 6. Session ends → Cleanup
|
||||
*/
|
||||
|
||||
// === Step 1: Context Injection (SessionStart) ===
|
||||
global.fetch = vi.fn().mockResolvedValueOnce({
|
||||
ok: true,
|
||||
status: 200,
|
||||
text: async () => '# [claude-mem] recent context\n\nNo observations yet.'
|
||||
});
|
||||
|
||||
const contextResponse = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/context/inject?project=claude-mem`
|
||||
);
|
||||
expect(contextResponse.ok).toBe(true);
|
||||
const contextText = await contextResponse.text();
|
||||
expect(contextText).toContain('recent context');
|
||||
|
||||
// === Step 2 & 3: Tool runs, Observation captured (PostToolUse) ===
|
||||
global.fetch = vi.fn().mockResolvedValueOnce({
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({ status: 'queued', observationId: 1 })
|
||||
});
|
||||
|
||||
const observationResponse = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/sessions/observations`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
claudeSessionId: sessionId,
|
||||
tool_name: bashCommandScenario.tool_name,
|
||||
tool_input: bashCommandScenario.tool_input,
|
||||
tool_response: bashCommandScenario.tool_response,
|
||||
cwd: '/project/claude-mem'
|
||||
})
|
||||
}
|
||||
);
|
||||
expect(observationResponse.ok).toBe(true);
|
||||
const obsResult = await observationResponse.json();
|
||||
expect(obsResult.status).toBe('queued');
|
||||
|
||||
// === Step 4: Simulate SDK processing and saving observation ===
|
||||
// In a real flow, the SDK would process the tool data and generate an observation
|
||||
// For this test, we simulate the observation being saved to the database
|
||||
|
||||
// === Step 5: Search finds the observation ===
|
||||
global.fetch = vi.fn().mockResolvedValueOnce({
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({
|
||||
results: [
|
||||
{
|
||||
id: 1,
|
||||
title: 'Git status check',
|
||||
content: 'Checked repository status, working tree clean',
|
||||
type: 'discovery',
|
||||
files: [],
|
||||
created_at: new Date().toISOString()
|
||||
}
|
||||
],
|
||||
total: 1
|
||||
})
|
||||
});
|
||||
|
||||
const searchResponse = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/search?query=git+status&project=claude-mem`
|
||||
);
|
||||
expect(searchResponse.ok).toBe(true);
|
||||
const searchResults = await searchResponse.json();
|
||||
expect(searchResults.results).toHaveLength(1);
|
||||
expect(searchResults.results[0].title).toContain('Git');
|
||||
|
||||
// === Step 6: Session summary (Stop) ===
|
||||
global.fetch = vi.fn().mockResolvedValueOnce({
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({ status: 'queued' })
|
||||
});
|
||||
|
||||
const summaryResponse = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/sessions/summarize`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
claudeSessionId: sessionId,
|
||||
last_user_message: 'Thanks!',
|
||||
last_assistant_message: 'Checked git status successfully.',
|
||||
cwd: '/project/claude-mem'
|
||||
})
|
||||
}
|
||||
);
|
||||
expect(summaryResponse.ok).toBe(true);
|
||||
|
||||
// === Step 7: Session cleanup (SessionEnd) ===
|
||||
global.fetch = vi.fn().mockResolvedValueOnce({
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({ status: 'completed' })
|
||||
});
|
||||
|
||||
const cleanupResponse = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/sessions/complete`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
claudeSessionId: sessionId,
|
||||
reason: 'user_exit'
|
||||
})
|
||||
}
|
||||
);
|
||||
expect(cleanupResponse.ok).toBe(true);
|
||||
|
||||
// Verify: All steps completed successfully
|
||||
expect(global.fetch).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('handles multiple observations in a single session', async () => {
|
||||
/**
|
||||
* Tests a more realistic session with multiple tool uses
|
||||
* and observations being generated.
|
||||
*/
|
||||
|
||||
// Track all observations in this session
|
||||
const observations: any[] = [];
|
||||
|
||||
// Mock worker to accept multiple observations
|
||||
let obsCount = 0;
|
||||
global.fetch = vi.fn().mockImplementation(async (url: string, options?: any) => {
|
||||
if (url.includes('/api/sessions/observations') && options?.method === 'POST') {
|
||||
obsCount++;
|
||||
const body = JSON.parse(options.body);
|
||||
observations.push(body);
|
||||
return {
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({ status: 'queued', observationId: obsCount })
|
||||
};
|
||||
}
|
||||
if (url.includes('/api/search')) {
|
||||
return {
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({
|
||||
results: observations.map((obs, i) => ({
|
||||
id: i + 1,
|
||||
title: `Observation ${i + 1}`,
|
||||
content: `Tool: ${obs.tool_name}`,
|
||||
type: 'discovery',
|
||||
created_at: new Date().toISOString()
|
||||
})),
|
||||
total: observations.length
|
||||
})
|
||||
};
|
||||
}
|
||||
return { ok: true, status: 200, json: async () => ({}) };
|
||||
});
|
||||
|
||||
// Simulate 5 different tool uses
|
||||
const tools = [
|
||||
{ name: 'Bash', input: { command: 'npm test' } },
|
||||
{ name: 'Read', input: { file_path: '/src/index.ts' } },
|
||||
{ name: 'Edit', input: { file_path: '/src/index.ts', old_string: 'old', new_string: 'new' } },
|
||||
{ name: 'Grep', input: { pattern: 'function', path: '/src' } },
|
||||
{ name: 'Write', input: { file_path: '/src/new.ts', content: 'code' } }
|
||||
];
|
||||
|
||||
// Send observations for each tool
|
||||
for (const tool of tools) {
|
||||
const response = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/sessions/observations`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
claudeSessionId: sessionId,
|
||||
tool_name: tool.name,
|
||||
tool_input: tool.input,
|
||||
tool_response: { success: true },
|
||||
cwd: '/project'
|
||||
})
|
||||
}
|
||||
);
|
||||
expect(response.ok).toBe(true);
|
||||
}
|
||||
|
||||
// Verify: All observations were queued
|
||||
expect(observations).toHaveLength(5);
|
||||
expect(observations.map(o => o.tool_name)).toEqual(['Bash', 'Read', 'Edit', 'Grep', 'Write']);
|
||||
|
||||
// Search finds all observations
|
||||
const searchResponse = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/search?query=observation&project=test-project`
|
||||
);
|
||||
const searchResults = await searchResponse.json();
|
||||
expect(searchResults.results).toHaveLength(5);
|
||||
});
|
||||
|
||||
it('preserves context across session lifecycle', async () => {
|
||||
/**
|
||||
* Tests that observations from one session can be found
|
||||
* when starting a new session in the same project.
|
||||
*/
|
||||
|
||||
// Session 1: Create some observations
|
||||
global.fetch = vi.fn().mockImplementation(async (url: string, options?: any) => {
|
||||
if (url.includes('/api/sessions/observations')) {
|
||||
return {
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({ status: 'queued', observationId: 1 })
|
||||
};
|
||||
}
|
||||
if (url.includes('/api/context/inject')) {
|
||||
return {
|
||||
ok: true,
|
||||
status: 200,
|
||||
text: async () => `# [test-project] recent context
|
||||
|
||||
## Recent Work (1 observation)
|
||||
|
||||
### [bugfix] Fixed parser bug
|
||||
The XML parser now handles self-closing tags correctly.
|
||||
Files: /src/parser.ts`
|
||||
};
|
||||
}
|
||||
return { ok: true, status: 200, json: async () => ({}) };
|
||||
});
|
||||
|
||||
// Session 1: Add observation
|
||||
await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/sessions/observations`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
claudeSessionId: 'session-1',
|
||||
tool_name: 'Edit',
|
||||
tool_input: { file_path: '/src/parser.ts' },
|
||||
tool_response: { success: true },
|
||||
cwd: '/project/test-project'
|
||||
})
|
||||
}
|
||||
);
|
||||
|
||||
// Session 2: Start new session, should see context from session 1
|
||||
const contextResponse = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/context/inject?project=test-project`
|
||||
);
|
||||
const context = await contextResponse.text();
|
||||
|
||||
// Verify: Context includes previous session's work
|
||||
expect(context).toContain('Fixed parser bug');
|
||||
expect(context).toContain('parser.ts');
|
||||
});
|
||||
|
||||
it('handles error recovery gracefully', async () => {
|
||||
/**
|
||||
* Tests that the system continues to work even if some
|
||||
* operations fail along the way.
|
||||
*/
|
||||
|
||||
let callCount = 0;
|
||||
global.fetch = vi.fn().mockImplementation(async () => {
|
||||
callCount++;
|
||||
|
||||
// First call fails (simulating transient error)
|
||||
if (callCount === 1) {
|
||||
return {
|
||||
ok: false,
|
||||
status: 500,
|
||||
json: async () => ({ error: 'Temporary error' })
|
||||
};
|
||||
}
|
||||
|
||||
// Subsequent calls succeed
|
||||
return {
|
||||
ok: true,
|
||||
status: 200,
|
||||
json: async () => ({ status: 'queued' })
|
||||
};
|
||||
});
|
||||
|
||||
// First attempt fails
|
||||
const firstAttempt = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/sessions/observations`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
claudeSessionId: sessionId,
|
||||
tool_name: 'Bash',
|
||||
tool_input: { command: 'test' },
|
||||
tool_response: {},
|
||||
cwd: '/project'
|
||||
})
|
||||
}
|
||||
);
|
||||
expect(firstAttempt.ok).toBe(false);
|
||||
|
||||
// Retry succeeds
|
||||
const secondAttempt = await fetch(
|
||||
`http://127.0.0.1:${WORKER_PORT}/api/sessions/observations`,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
claudeSessionId: sessionId,
|
||||
tool_name: 'Bash',
|
||||
tool_input: { command: 'test' },
|
||||
tool_response: {},
|
||||
cwd: '/project'
|
||||
})
|
||||
}
|
||||
);
|
||||
expect(secondAttempt.ok).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,256 +0,0 @@
|
||||
/**
|
||||
* Integration Test: Hook Execution Environments
|
||||
*
|
||||
* Tests that hooks can execute successfully in various shell environments,
|
||||
* particularly fish shell where PATH handling differs from bash.
|
||||
*
|
||||
* Prevents regression of Issue #264: "Plugin hooks fail with fish shell
|
||||
* because bun not found in /bin/sh PATH"
|
||||
*/
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
||||
import { spawnSync } from 'child_process';
|
||||
import { getBunPath, getBunPathOrThrow } from '../../src/utils/bun-path.js';
|
||||
|
||||
describe('Hook Execution Environments', () => {
|
||||
describe('Bun PATH resolution in hooks', () => {
|
||||
it('finds bun when only in ~/.bun/bin/bun (fish shell scenario)', () => {
|
||||
// Simulate fish shell environment where:
|
||||
// - User has bun installed via curl install
|
||||
// - bun is in ~/.bun/bin/bun
|
||||
// - BUT fish doesn't export PATH to child processes properly
|
||||
// - /bin/sh (used by hooks) can't find bun in PATH
|
||||
|
||||
const originalPath = process.env.PATH;
|
||||
const homeDir = process.env.HOME || '/Users/testuser';
|
||||
|
||||
try {
|
||||
// Remove bun from PATH (simulate /bin/sh environment)
|
||||
process.env.PATH = '/usr/bin:/bin:/usr/sbin:/sbin';
|
||||
|
||||
// getBunPath should check common install locations
|
||||
const bunPath = getBunPath();
|
||||
|
||||
// Should find bun in one of these locations:
|
||||
// - ~/.bun/bin/bun
|
||||
// - /usr/local/bin/bun
|
||||
// - /opt/homebrew/bin/bun
|
||||
expect(bunPath).toBeTruthy();
|
||||
|
||||
if (bunPath) {
|
||||
// Should be absolute path
|
||||
expect(bunPath.startsWith('/')).toBe(true);
|
||||
|
||||
// Verify it's actually executable
|
||||
const result = spawnSync(bunPath, ['--version']);
|
||||
expect(result.status).toBe(0);
|
||||
}
|
||||
} finally {
|
||||
process.env.PATH = originalPath;
|
||||
}
|
||||
});
|
||||
|
||||
it('throws actionable error when bun not found anywhere', () => {
|
||||
const originalPath = process.env.PATH;
|
||||
|
||||
try {
|
||||
// Completely remove bun from PATH
|
||||
process.env.PATH = '/usr/bin:/bin';
|
||||
|
||||
// Mock file system to simulate bun not installed
|
||||
vi.mock('fs', () => ({
|
||||
existsSync: vi.fn().mockReturnValue(false)
|
||||
}));
|
||||
|
||||
expect(() => {
|
||||
getBunPathOrThrow();
|
||||
}).toThrow();
|
||||
|
||||
try {
|
||||
getBunPathOrThrow();
|
||||
} catch (error: any) {
|
||||
// Error should be actionable
|
||||
expect(error.message).toContain('Bun is required');
|
||||
|
||||
// Should suggest installation
|
||||
expect(error.message.toLowerCase()).toMatch(/install|download|setup/);
|
||||
}
|
||||
} finally {
|
||||
process.env.PATH = originalPath;
|
||||
vi.unmock('fs');
|
||||
}
|
||||
});
|
||||
|
||||
it('prefers bun in PATH over hard-coded locations', () => {
|
||||
const originalPath = process.env.PATH;
|
||||
|
||||
try {
|
||||
// Set PATH to include bun
|
||||
process.env.PATH = '/usr/local/bin:/usr/bin:/bin';
|
||||
|
||||
const bunPath = getBunPath();
|
||||
|
||||
// If bun is in PATH, should return just "bun"
|
||||
// (faster, respects user's PATH priority)
|
||||
if (bunPath === 'bun') {
|
||||
expect(bunPath).toBe('bun');
|
||||
} else {
|
||||
// Otherwise should be absolute path
|
||||
expect(bunPath?.startsWith('/')).toBe(true);
|
||||
}
|
||||
} finally {
|
||||
process.env.PATH = originalPath;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Hook execution with different shells', () => {
|
||||
it('save-hook can execute when bun not in PATH', async () => {
|
||||
// This would require spawning actual hook process
|
||||
// For now, verify that hooks use getBunPath() correctly
|
||||
|
||||
const bunPath = getBunPath();
|
||||
expect(bunPath).toBeTruthy();
|
||||
|
||||
// Hooks should use this resolved path, not just "bun"
|
||||
// Otherwise fish shell users will get "command not found" errors
|
||||
});
|
||||
|
||||
it('worker-utils uses resolved bun path for PM2', () => {
|
||||
// worker-utils.ts spawns PM2 with bun
|
||||
// It should use getBunPathOrThrow() not hardcoded "bun"
|
||||
|
||||
expect(true).toBe(true); // Placeholder - verify in worker-utils.ts
|
||||
});
|
||||
});
|
||||
|
||||
describe('Error messages for PATH issues', () => {
|
||||
it('hook failure includes PATH diagnostic information', () => {
|
||||
// When hook fails with "command not found"
|
||||
// Error should include:
|
||||
// - Current PATH value
|
||||
// - Locations checked for bun
|
||||
// - Installation instructions
|
||||
|
||||
const originalPath = process.env.PATH;
|
||||
|
||||
try {
|
||||
process.env.PATH = '/usr/bin:/bin';
|
||||
|
||||
try {
|
||||
getBunPathOrThrow();
|
||||
expect.fail('Should have thrown');
|
||||
} catch (error: any) {
|
||||
// Should help user diagnose PATH issue
|
||||
expect(error.message).toBeTruthy();
|
||||
}
|
||||
} finally {
|
||||
process.env.PATH = originalPath;
|
||||
}
|
||||
});
|
||||
|
||||
it('suggests fish shell PATH fix in error message', () => {
|
||||
// If bun found in ~/.bun/bin but not in PATH
|
||||
// Error should suggest adding to fish config
|
||||
|
||||
// This is a UX improvement - not currently implemented
|
||||
// But would help users fix Issue #264 themselves
|
||||
|
||||
expect(true).toBe(true); // Placeholder for future enhancement
|
||||
});
|
||||
});
|
||||
|
||||
describe('Cross-platform bun resolution', () => {
|
||||
it('checks correct paths on macOS', () => {
|
||||
if (process.platform !== 'darwin') {
|
||||
return; // Skip on non-macOS
|
||||
}
|
||||
|
||||
// On macOS, should check:
|
||||
// - ~/.bun/bin/bun
|
||||
// - /opt/homebrew/bin/bun (Apple Silicon)
|
||||
// - /usr/local/bin/bun (Intel)
|
||||
|
||||
const bunPath = getBunPath();
|
||||
expect(bunPath).toBeTruthy();
|
||||
});
|
||||
|
||||
it('checks correct paths on Linux', () => {
|
||||
if (process.platform !== 'linux') {
|
||||
return; // Skip on non-Linux
|
||||
}
|
||||
|
||||
// On Linux, should check:
|
||||
// - ~/.bun/bin/bun
|
||||
// - /usr/local/bin/bun
|
||||
|
||||
const bunPath = getBunPath();
|
||||
expect(bunPath).toBeTruthy();
|
||||
});
|
||||
|
||||
it('handles Windows paths correctly', () => {
|
||||
if (process.platform !== 'win32') {
|
||||
return; // Skip on non-Windows
|
||||
}
|
||||
|
||||
// On Windows, should check:
|
||||
// - %USERPROFILE%\.bun\bin\bun.exe
|
||||
|
||||
const bunPath = getBunPath();
|
||||
expect(bunPath).toBeTruthy();
|
||||
|
||||
if (bunPath && bunPath !== 'bun') {
|
||||
// Windows paths should use backslashes or be normalized
|
||||
expect(bunPath.includes('\\') || bunPath.includes('/')).toBe(true);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Hook subprocess environment inheritance', () => {
|
||||
it('hooks inherit correct environment variables', () => {
|
||||
// When Claude spawns hooks as subprocesses
|
||||
// Hooks should have access to:
|
||||
// - USER/HOME
|
||||
// - PATH (or be able to find bun without it)
|
||||
// - CLAUDE_MEM_* settings
|
||||
|
||||
expect(process.env.HOME).toBeTruthy();
|
||||
});
|
||||
|
||||
it('hooks work when spawned by /bin/sh', () => {
|
||||
// Fish shell issue: Fish sets PATH, but /bin/sh doesn't inherit it
|
||||
// Hooks must use getBunPath() to find bun without relying on PATH
|
||||
|
||||
const bunPath = getBunPath();
|
||||
expect(bunPath).toBeTruthy();
|
||||
|
||||
// Should NOT require PATH to include bun
|
||||
});
|
||||
});
|
||||
|
||||
describe('Real-world shell scenarios', () => {
|
||||
it('handles fish shell with custom PATH', () => {
|
||||
// Fish users often have PATH in config.fish
|
||||
// But hooks run under /bin/sh, which doesn't source config.fish
|
||||
|
||||
expect(true).toBe(true); // Verified by getBunPath() logic
|
||||
});
|
||||
|
||||
it('handles zsh with homebrew in non-standard location', () => {
|
||||
// M1/M2 Macs have homebrew in /opt/homebrew
|
||||
// Intel Macs have homebrew in /usr/local
|
||||
|
||||
const bunPath = getBunPath();
|
||||
if (bunPath && bunPath !== 'bun') {
|
||||
// Should find bun in either location
|
||||
expect(bunPath.includes('/homebrew/') || bunPath.includes('/local/')).toBeTruthy();
|
||||
}
|
||||
});
|
||||
|
||||
it('handles bash with bun installed via curl', () => {
|
||||
// Bun's recommended install: curl -fsSL https://bun.sh/install | bash
|
||||
// This installs to ~/.bun/bin/bun
|
||||
|
||||
expect(true).toBe(true); // Verified by getBunPath() checking ~/.bun/bin
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user