drtrace 0.2.0 → 0.4.0

package/dist/init.js

@@ -44,10 +44,13 @@ exports.ProjectInitializer = void 0;
 exports.runInitProject = runInitProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const prompts_1 = __importDefault(require("prompts"));
 const config_schema_1 = require("./config-schema");
 class ProjectInitializer {
     constructor(projectRoot = process.cwd()) {
+        // Track copied agent files for summary display
+        this.copiedAgentFiles = [];
         this.projectRoot = projectRoot;
         this.drtraceDir = path.join(projectRoot, "_drtrace");
         this.configPath = path.join(this.drtraceDir, "config.json");
@@ -58,13 +61,18 @@ class ProjectInitializer {
     async runInteractive() {
         console.log("\n🚀 DrTrace Project Initialization\n");
         console.log("=".repeat(50));
+        // Check for existing config FIRST (before collecting project info)
+        if (!(await this.handleExistingConfig())) {
+            console.log("\n❌ Initialization cancelled.");
+            return false;
+        }
         // Collect project information
         console.log("\n📋 Project Information:");
         const projectName = await this.promptText("Project name", "my-app");
         const applicationId = await this.promptText("Application ID", projectName.toLowerCase().replace(/\s+/g, "-"));
         // Language selection
         console.log("\n🔧 Technology Stack:");
-        const language = await this.promptChoice("Select language/runtime:", ["python", "javascript", "both"], "javascript");
+        const language = await this.promptChoice("Select language/runtime:", ["python", "javascript", "cpp", "both"], "javascript");
         // Daemon configuration
         console.log("\n📡 DrTrace Daemon Configuration:");
         const daemonUrl = await this.promptText("Daemon URL", "http://localhost:8001");
@@ -80,11 +88,6 @@ class ProjectInitializer {
         if (agentEnabled) {
             agentFramework = await this.promptChoice("Select agent framework:", ["bmad", "langchain", "other"], "bmad");
         }
-        // Check for existing config
-        if (!this.handleExistingConfig()) {
-            console.log("\n❌ Initialization cancelled.");
-            return false;
-        }
         // Create directory structure
         this.createDirectoryStructure();
         // Generate and save main config
@@ -106,6 +109,12 @@ class ProjectInitializer {
         if (agentEnabled) {
             this.copyAgentSpec();
         }
+        // Copy framework-specific guides for C++ projects
+        if (language === "cpp" || language === "both") {
+            this.copyFrameworkGuides();
+            // Copy C++ header file for C++ projects
+            this.copyCppHeader();
+        }
         // Generate .env.example
         this.generateEnvExample(config);
         // Generate README
@@ -165,23 +174,47 @@ class ProjectInitializer {
         return response.value || [];
     }
     /**
-     * Handle existing config
+     * Handle existing config - prompt user before overwriting
+     *
+     * Returns true if initialization should proceed, false if user declined.
      */
-    handleExistingConfig() {
+    async handleExistingConfig() {
         if (!fs.existsSync(this.configPath)) {
-            return true;
+            return true; // No existing config, proceed
         }
         console.log(`\n⚠️  Configuration already exists at ${this.configPath}`);
-        // In interactive mode, we would prompt here
-        // For now, we'll require confirmation via prompts
-        return true;
+        // Prompt user if they want to overwrite
+        const overwriteResponse = await (0, prompts_1.default)({
+            type: "confirm",
+            name: "value",
+            message: "Overwrite existing configuration?",
+            initial: false, // Default to No (safe)
+        });
+        if (!overwriteResponse.value) {
+            return false; // User declined, stop initialization
+        }
+        // Optional: Offer backup
+        const backupResponse = await (0, prompts_1.default)({
+            type: "confirm",
+            name: "value",
+            message: "Create backup of existing config?",
+            initial: true, // Default to Yes (safe)
+        });
+        if (backupResponse.value) {
+            const backupPath = this.configPath + ".bak";
+            fs.copyFileSync(this.configPath, backupPath);
+            console.log(`✓ Backup created at ${backupPath}`);
+        }
+        return true; // User confirmed, proceed with overwrite
     }
     /**
      * Create _drtrace directory structure
      */
     createDirectoryStructure() {
         const agentsDir = path.join(this.drtraceDir, "agents");
+        const integrationGuidesDir = path.join(this.drtraceDir, "agents", "integration-guides");
         fs.mkdirSync(agentsDir, { recursive: true });
+        fs.mkdirSync(integrationGuidesDir, { recursive: true });
         console.log(`✓ Created directory: ${this.drtraceDir}`);
     }
     /**
@@ -197,44 +230,400 @@ class ProjectInitializer {
         }
     }
     /**
-     * Copy agent spec to _drtrace/agents/
+     * Copy all agent files from packaged resources to _drtrace/agents/
+     * Copies everything from agents/ directory including:
+     * - Agent spec files (*.md)
+     * - Integration guides (integration-guides/*.md)
+     * - Any other files (README.md, CONTRIBUTING.md, etc.)
      */
     copyAgentSpec() {
         try {
-            const agentPath = path.join(this.drtraceDir, "agents", "log-analysis.md");
-            const defaultSpec = this.getDefaultAgentSpec();
-            fs.writeFileSync(agentPath, defaultSpec);
-            console.log(`✓ Copied agent spec: ${agentPath}`);
+            // Try multiple locations for agents directory
+            const possibleAgentsDirs = [
+                // Installed package location - dist/resources/agents (production)
+                path.join(this.projectRoot, "node_modules", "drtrace", "dist", "resources", "agents"),
+                // Installed package location - agents (legacy, may be empty)
+                path.join(this.projectRoot, "node_modules", "drtrace", "agents"),
+                // Development mode (monorepo)
+                path.join(process.cwd(), "agents"),
+                // Relative to package
+                path.resolve(__dirname, "../../agents"),
+                // Relative to dist
+                path.resolve(__dirname, "../agents"),
+            ];
+            let agentsDir = null;
+            for (const dir of possibleAgentsDirs) {
+                if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
+                    agentsDir = dir;
+                    break;
+                }
+            }
+            if (!agentsDir) {
+                console.warn("⚠️  Could not find agents directory");
+                return;
+            }
+            // Copy all files recursively and track copied files
+            const copiedFiles = this.copyAgentsRecursive(agentsDir, path.join(this.drtraceDir, "agents"));
+            this.copiedAgentFiles.push(...copiedFiles);
         }
         catch (error) {
-            console.warn(`⚠️  Could not copy agent spec: ${error}`);
+            console.warn(`⚠️  Could not copy agent files: ${error}`);
         }
     }
+    /**
+     * Recursively copy all files from sourceDir to targetDir
+     * Returns list of relative file paths copied (for summary display)
+     */
+    copyAgentsRecursive(sourceDir, targetDir, basePath = "") {
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir, { recursive: true });
+        }
+        const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+        const copiedFiles = [];
+        for (const entry of entries) {
+            const srcPath = path.join(sourceDir, entry.name);
+            const destPath = path.join(targetDir, entry.name);
+            const relativePath = basePath ? path.join(basePath, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                // Recursively copy directories
+                const subCopied = this.copyAgentsRecursive(srcPath, destPath, relativePath);
+                copiedFiles.push(...subCopied);
+            }
+            else {
+                // Copy file (no renaming needed - files are already named correctly)
+                fs.copyFileSync(srcPath, destPath);
+                copiedFiles.push(relativePath);
+                console.log(`✓ Copied ${relativePath}`);
+            }
+        }
+        // Print summary only at top level
+        if (!basePath && copiedFiles.length > 0) {
+            console.log(`✓ Successfully copied ${copiedFiles.length} file(s) from agents/`);
+        }
+        return copiedFiles;
+    }
+    /**
+     * Copy framework-specific integration guides to _drtrace/agents/integration-guides/
+     * Dynamically discovers all .md files in agents/integration-guides/ directory
+     * Guides are stored in agents folder so agents can access them on client side
+     */
+    copyFrameworkGuides() {
+        const integrationGuidesDir = path.join(this.drtraceDir, "agents", "integration-guides");
+        fs.mkdirSync(integrationGuidesDir, { recursive: true });
+        // Dynamically discover framework guides from agents/integration-guides/ directory
+        const rootGuidesDir = path.join(process.cwd(), "agents", "integration-guides");
+        let frameworkGuides = [];
+        // Try root agents/integration-guides/ first (development mode)
+        if (fs.existsSync(rootGuidesDir)) {
+            try {
+                const files = fs.readdirSync(rootGuidesDir);
+                frameworkGuides = files
+                    .filter((file) => file.endsWith(".md"))
+                    .map((file) => file.replace(/\.md$/, ""));
+            }
+            catch (error) {
+                // If directory exists but can't read it, warn and continue
+                console.warn(`⚠️  Could not read integration guides directory: ${error}`);
+            }
+        }
+        // If no guides found in development mode, try bundled resources (production mode)
+        if (frameworkGuides.length === 0) {
+            try {
+                // Try to load from bundled resources (production mode)
+                // Path: node_modules/drtrace/dist/resources/agents/integration-guides/
+                // Note: In production, __dirname points to dist/ directory
+                const bundledResourcesPath = path.join(__dirname, "resources", "agents", "integration-guides");
+                if (fs.existsSync(bundledResourcesPath)) {
+                    const files = fs.readdirSync(bundledResourcesPath);
+                    frameworkGuides = files
+                        .filter((file) => file.endsWith(".md"))
+                        .map((file) => file.replace(/\.md$/, ""));
+                }
+            }
+            catch (error) {
+                // If bundled resources not available, continue gracefully
+                // This is expected in development mode when resources aren't bundled yet
+            }
+        }
+        // Copy each discovered guide
+        for (const guideName of frameworkGuides) {
+            try {
+                const guideFilename = `${guideName}.md`;
+                const guidePath = path.join(integrationGuidesDir, guideFilename);
+                // Try root agents/integration-guides/ first (development mode)
+                const rootGuidePath = path.join(rootGuidesDir, guideFilename);
+                let content;
+                if (fs.existsSync(rootGuidePath)) {
+                    content = fs.readFileSync(rootGuidePath, "utf-8");
+                }
+                else {
+                    // Try to load from bundled resources (production mode)
+                    try {
+                        const bundledGuidePath = path.join(__dirname, "resources", "agents", "integration-guides", guideFilename);
+                        if (fs.existsSync(bundledGuidePath)) {
+                            content = fs.readFileSync(bundledGuidePath, "utf-8");
+                        }
+                        else {
+                            // Skip if guide not found
+                            continue;
+                        }
+                    }
+                    catch (error) {
+                        // Skip if guide not found
+                        continue;
+                    }
+                }
+                fs.writeFileSync(guidePath, content);
+                console.log(`✓ Copied framework guide: ${guidePath}`);
+            }
+            catch (error) {
+                console.warn(`⚠️  Could not copy ${guideName} framework guide: ${error}`);
+            }
+        }
+    }
+    /**
+     * Copy C++ header file to third_party/drtrace/ for C++ projects.
+     *
+     * This enables header-only integration:
+     *   - Header is copied to third_party/drtrace/drtrace_sink.hpp
+     *   - Users include it via #include "third_party/drtrace/drtrace_sink.hpp"
+     *   - Note: third_party/drtrace/ should be committed to git (unlike _drtrace/ which is gitignored)
+     */
+    copyCppHeader() {
+        const sourcePath = this.findCppHeaderSource();
+        if (!sourcePath || !fs.existsSync(sourcePath)) {
+            console.warn("⚠️  Could not find drtrace_sink.hpp - C++ header-only integration " +
+                "will not be available.");
+            return;
+        }
+        // Destination: third_party/drtrace/drtrace_sink.hpp (committed to git)
+        const destDir = path.join(this.projectRoot, "third_party", "drtrace");
+        fs.mkdirSync(destDir, { recursive: true });
+        const destPath = path.join(destDir, "drtrace_sink.hpp");
+        try {
+            fs.copyFileSync(sourcePath, destPath);
+            console.log(`✓ Copied C++ header: ${destPath}`);
+            console.log("  Note: third_party/drtrace/ should be committed to git");
+        }
+        catch (error) {
+            console.warn(`⚠️  Failed to copy C++ header from ${sourcePath} to ${destPath}: ${error}`);
+        }
+    }
+    /**
+     * Find drtrace_sink.hpp source file for header-only C++ integration.
+     *
+     * Search order:
+     *   1. npm package location: dist/resources/cpp/drtrace_sink.hpp (production mode)
+     *   2. Monorepo development layout: packages/cpp/drtrace-client/src/drtrace_sink.hpp
+     *   3. pip package location: site-packages/drtrace_service/.../packages/cpp/drtrace-client/src/drtrace_sink.hpp (if Python available)
+     *
+     * @returns Path to header file if found, null otherwise
+     */
+    findCppHeaderSource() {
+        // 1. Check npm package location (production mode)
+        // Path: node_modules/drtrace/dist/resources/cpp/drtrace_sink.hpp
+        // In production, __dirname points to dist/ directory
+        const npmPackagePath = path.join(__dirname, "resources", "cpp", "drtrace_sink.hpp");
+        if (fs.existsSync(npmPackagePath)) {
+            return npmPackagePath;
+        }
+        // 2. Check monorepo location (development mode)
+        // Search upward from project root (max 6 levels)
+        let searchRoot = process.cwd();
+        for (let i = 0; i < 6; i++) {
+            const monorepoPath = path.join(searchRoot, "packages", "cpp", "drtrace-client", "src", "drtrace_sink.hpp");
+            if (fs.existsSync(monorepoPath)) {
+                return monorepoPath;
+            }
+            const parent = path.dirname(searchRoot);
+            if (parent === searchRoot) {
+                break; // Reached filesystem root
+            }
+            searchRoot = parent;
+        }
+        // 3. Check pip package location (if Python available)
+        // Try to use Python to find the package location
+        try {
+            const pythonCmd = `python3 -c "import drtrace_service; import os; print(os.path.dirname(drtrace_service.__file__))"`;
+            const packageDir = (0, child_process_1.execSync)(pythonCmd, { encoding: "utf-8" }).trim();
+            const pipPackagePath = path.join(packageDir, "packages", "cpp", "drtrace-client", "src", "drtrace_sink.hpp");
+            if (fs.existsSync(pipPackagePath)) {
+                return pipPackagePath;
+            }
+        }
+        catch (error) {
+            // Python not available or package not installed - continue
+        }
+        return null;
+    }
     /**
      * Get default agent spec from shared agents/ or bundled resources
      *
      * Search order:
      *   1. Root repo agents/ directory (development)
      *   2. Bundled default agent from node_modules
+     *
+     * @param agentName - Name of the agent: "log-analysis", "log-it", "log-init", or "log-help"
      */
-    getDefaultAgentSpec() {
-        // Try root agents/ first (development mode)
-        const rootAgentPath = path.join(this.projectRoot, "..", "..", "agents", "log-analysis.default.md");
+    getDefaultAgentSpec(agentName = "log-analysis") {
+        // Try multiple possible locations for agents folder
+        // Search order optimized: installed package first (most common), then repo root (development)
+        const possiblePaths = [];
+        // 1. Try node_modules/drtrace/agents/ directly from project root (most common case)
+        const nodeModulesPath = path.join(this.projectRoot, "node_modules", "drtrace", "agents", `${agentName}.md`);
+        possiblePaths.push(nodeModulesPath);
+        // 2. Try to find from installed package location (if installed via npm)
         try {
-            if (fs.existsSync(rootAgentPath)) {
-                return fs.readFileSync(rootAgentPath, "utf-8");
+            // Try to resolve the main entry point first, then find package.json
+            const mainPath = require.resolve("drtrace");
+            const packageDir = path.dirname(mainPath);
+            // Go up to find package.json (main might be in dist/ or root)
+            let currentDir = packageDir;
+            for (let i = 0; i < 3; i++) {
+                const pkgJsonPath = path.join(currentDir, "package.json");
+                if (fs.existsSync(pkgJsonPath)) {
+                    possiblePaths.push(path.join(currentDir, "agents", `${agentName}.md`));
+                    break;
+                }
+                currentDir = path.dirname(currentDir);
             }
         }
         catch (error) {
-            // Fall through to bundled resource
+            // Package not found, skip this path
+        }
+        // 3. From project root (when package is in monorepo or installed locally)
+        possiblePaths.push(path.join(this.projectRoot, "..", "..", "..", "agents", `${agentName}.md`));
+        // 4. Try absolute path from known repo structure
+        possiblePaths.push(path.resolve(this.projectRoot, "../../../agents", `${agentName}.md`));
+        for (const agentPath of possiblePaths) {
+            try {
+                if (fs.existsSync(agentPath)) {
+                    return fs.readFileSync(agentPath, "utf-8");
+                }
+            }
+            catch (error) {
+                // Continue to next path
+                continue;
+            }
         }
         // Fallback to bundled default agent
-        return this.getBundledAgentSpec();
+        return this.getBundledAgentSpec(agentName);
     }
     /**
      * Get bundled agent spec (fallback when root agents/ not available)
+     *
+     * @param agentName - Name of the agent: "log-analysis", "log-it", "log-init", or "log-help"
      */
-    getBundledAgentSpec() {
+    getBundledAgentSpec(agentName = "log-analysis") {
+        if (agentName === "log-it") {
+            // Return minimal log-it agent spec
+            return `---
+name: "log-it"
+description: "Strategic Logging Assistant"
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+\`\`\`xml
+<agent id="log-it.agent.yaml" name="drtrace" title="Strategic Logging Assistant" icon="📝">
+<activation critical="MANDATORY">
+  <step n="1">Load persona from this current agent file (already in context)</step>
+  <step n="2">Remember: You are a Strategic Logging Assistant specializing in efficient, privacy-conscious logging</step>
+  <step n="3">NEVER suggest logging code without first seeing actual code context from the user</step>
+  <step n="4">When user provides code, detect language automatically and apply appropriate patterns</step>
+  <step n="5">Validate EVERY suggested log statement against all 5 criteria:
+    1. **Efficiency**: Not in tight loops, uses lazy formatting, appropriate log level
+    2. **Necessity**: Provides actionable insight, explains WHY not just THAT, prevents spam
+    3. **No Sensitive Data**: Never logs passwords/tokens/PII, flags patterns, suggests masking
+    4. **Code Context**: Strategic placement (entry/exit, external calls, errors, decisions)
+    5. **Completeness**: Includes debug-worthy context (trace IDs, inputs/outputs, error details)
+  </step>
+  <step n="6">Always provide line numbers, log level reasoning, and copy-paste ready code</step>
+  <step n="7">Show greeting, then display numbered list of ALL menu items from menu section</step>
+  <step n="8">STOP and WAIT for user input - do NOT execute menu items automatically</step>
+  <step n="9">On user input: Process as natural language query or execute menu item if number/cmd provided</step>
+</activation>
+
+<persona>
+  <role>Strategic Logging Assistant</role>
+  <identity>Expert at adding strategic, efficient, and privacy-conscious logging to codebases</identity>
+  <communication_style>Clear and concise. Provides actionable logging suggestions with reasoning.</communication_style>
+</persona>
+\`\`\`
+
+## Strategic Logging Guide
+
+This agent helps you add effective logging to your codebase.
+
+### How to Use
+
+1. Share your code file or snippet
+2. Describe what you want to log or debug
+3. Get strategic logging suggestions with reasoning
+`;
+        }
+        if (agentName === "log-init") {
+            // Return minimal log-init agent spec
+            return `---
+name: "log-init"
+description: "DrTrace Setup Assistant"
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+\`\`\`xml
+<agent id="log-init.agent.yaml" name="drtrace" title="DrTrace Setup Assistant" icon="🔧">
+<activation critical="MANDATORY">
+  <step n="1">Load persona from this current agent file (already in context)</step>
+  <step n="2">Remember: You are a Setup Specialist for DrTrace integration</step>
+  <step n="3">NEVER suggest setup without first reading and analyzing actual project files</step>
+  <step n="4">Show greeting, then display numbered list of ALL menu items from menu section</step>
+  <step n="5">STOP and WAIT for user input - do NOT execute menu items automatically</step>
+</activation>
+
+<persona>
+  <role>Setup Specialist</role>
+  <identity>Expert at analyzing project structures and suggesting intelligent DrTrace integration</identity>
+  <communication_style>Clear and educational. Reads and analyzes project files before suggesting setup.</communication_style>
+</persona>
+\`\`\`
+
+## Setup Guide
+
+This agent helps you set up DrTrace in your project by analyzing your codebase and providing language-specific integration suggestions.
+`;
+        }
+        if (agentName === "log-help") {
+            // Return minimal log-help agent spec
+            return `---
+name: "log-help"
+description: "DrTrace Setup Guide"
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+\`\`\`xml
+<agent id="log-help.agent.yaml" name="drtrace" title="DrTrace Setup Guide" icon="📘">
+<activation critical="MANDATORY">
+  <step n="1">Load persona from this current agent file (already in context)</step>
+  <step n="2">Remember: You are a Setup Guide Assistant</step>
+  <step n="3">Show greeting, then display numbered list of ALL menu items from menu section</step>
+  <step n="4">STOP and WAIT for user input - do NOT execute menu items automatically</step>
+</activation>
+
+<persona>
+  <role>Setup Guide Assistant</role>
+  <identity>Expert at providing step-by-step guidance for DrTrace setup</identity>
+  <communication_style>Patient and educational. Provides clear, actionable steps.</communication_style>
+</persona>
+\`\`\`
+
+## Setup Guide
+
+This agent provides step-by-step guidance for setting up DrTrace in your project, tracking your progress and helping when you get stuck.
+`;
+        }
+        // Default log-analysis agent spec
         return `---
 name: "log-analysis"
 description: "Log Analysis Agent"
@@ -340,10 +729,44 @@ import { ConfigSchema } from 'drtrace';
 const config = ConfigSchema.load('./_drtrace/config.json');
 \`\`\`
 
+## Starting the DrTrace Daemon
+
+The DrTrace daemon must be running for your application to send logs. You have two options:
+
+### Option A: Docker Compose (Recommended)
+
+The easiest way to start both the database and daemon:
+
+\`\`\`bash
+# From the DrTrace repository root
+docker-compose up -d
+
+# Verify it's running
+curl http://localhost:8001/status
+\`\`\`
+
+### Option B: Native Python Daemon
+
+If you have Python and PostgreSQL installed:
+
+\`\`\`bash
+# Set database URL (if using PostgreSQL)
+export DRTRACE_DATABASE_URL="postgresql://postgres:postgres@localhost:5432/drtrace"
+
+# Start the daemon
+uvicorn drtrace_service.api:app --host localhost --port 8001
+
+# In another terminal, verify it's running
+python -m drtrace_service status
+\`\`\`
+
+**Note**: The daemon must be running before your application can send logs. Keep the daemon terminal open while developing.
+
 ## Further Reading
 
 - See \`docs/\` for complete documentation
 - Check \`agents/\` for agent specifications
+- Full quickstart guide: https://github.com/your-repo/docs/quickstart.md
 `;
         fs.writeFileSync(readmeFile, content);
         console.log(`✓ Generated: ${readmeFile}`);
@@ -362,14 +785,21 @@ const config = ConfigSchema.load('./_drtrace/config.json');
         }
         console.log(`   • ${path.join(this.drtraceDir, ".env.example")}`);
         console.log(`   • ${path.join(this.drtraceDir, "README.md")}`);
-        if (config.agent?.enabled) {
-            console.log(`   • ${path.join(this.drtraceDir, "agents", "log-analysis.md")}`);
+        // List all copied agent files (includes integration-guides/)
+        if (this.copiedAgentFiles.length > 0) {
+            console.log("\n📋 Agent Files:");
+            for (const agentFile of this.copiedAgentFiles.sort()) {
+                console.log(`   • ${path.join(this.drtraceDir, "agents", agentFile)}`);
+            }
         }
         console.log("\n📖 Next Steps:");
         console.log(`   1. Review ${this.configPath}`);
         console.log(`   2. Create .env: cp ${path.join(this.drtraceDir, ".env.example")} .env`);
-        console.log(`   3. Start the daemon: drtrace daemon start`);
-        console.log(`   4. Read ${path.join(this.drtraceDir, "README.md")} for more details`);
+        console.log(`   3. Start the daemon:`);
+        console.log(`      Option A (Docker - Recommended): docker-compose up -d`);
+        console.log(`      Option B (Native): uvicorn drtrace_service.api:app --host localhost --port 8001`);
+        console.log(`   4. Verify daemon: python -m drtrace_service status`);
+        console.log(`   5. Read ${path.join(this.drtraceDir, "README.md")} for more details`);
         console.log("\n" + "=".repeat(50) + "\n");
     }
 }

package/dist/logger.d.ts

@@ -3,13 +3,20 @@ import { LogQueue } from './queue';
 export declare class DrTraceLogger {
     private queue;
     private applicationId;
+    private moduleName;
     private logLevel;
     private originalConsole?;
     constructor(opts: {
         queue: LogQueue;
         applicationId: string;
+        moduleName?: string;
         logLevel: LogLevel;
     });
+    /**
+     * Serialize a value to a string suitable for logging.
+     * Handles objects, arrays, errors, and primitives correctly.
+     */
+    private serialize;
     attachToConsole(): void;
     detachFromConsole(): void;
     log(level: LogLevel, message: string, context?: Record<string, unknown>): void;