copilot-tracer 1.0.3 → 1.0.5

package/dist/db.js

@@ -8,10 +8,20 @@ if (!fs.existsSync(DB_DIR))
     fs.mkdirSync(DB_DIR, { recursive: true });
 const db = new Database(DB_PATH);
 db.exec(`
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    path TEXT NOT NULL UNIQUE,
+    repo_url TEXT,
+    local_path TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
   CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
     started_at TEXT NOT NULL,
-    ended_at TEXT
+    ended_at TEXT,
+    project_id TEXT REFERENCES projects(id)
   );
 
   CREATE TABLE IF NOT EXISTS traces (
@@ -38,8 +48,113 @@ db.exec(`
     FOREIGN KEY(session_id) REFERENCES sessions(id)
   );
 `);
-export function createSession(id) {
-    db.prepare('INSERT OR REPLACE INTO sessions (id, started_at) VALUES (?, ?)').run(id, new Date().toISOString());
+// Migrate existing DBs
+try {
+    db.prepare('ALTER TABLE projects ADD COLUMN repo_url TEXT').run();
+}
+catch { }
+try {
+    db.prepare('ALTER TABLE projects ADD COLUMN local_path TEXT').run();
+}
+catch { }
+try {
+    db.prepare('ALTER TABLE sessions ADD COLUMN project_id TEXT REFERENCES projects(id)').run();
+}
+catch { }
+export function ensureProject(projectPath, repoUrl) {
+    const id = 'project:' + projectPath;
+    const now = new Date().toISOString();
+    db.prepare('INSERT OR IGNORE INTO projects (id, path, repo_url, local_path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)').run(id, projectPath, repoUrl ?? null, projectPath, now, now);
+    if (repoUrl) {
+        db.prepare('UPDATE projects SET repo_url = ?, updated_at = ? WHERE id = ?').run(repoUrl, now, id);
+    }
+    db.prepare('UPDATE projects SET updated_at = ? WHERE id = ?').run(now, id);
+    return id;
+}
+export function ensureProjectByRepo(repoUrl) {
+    // Try to find existing project by repo URL
+    const existing = db.prepare('SELECT id FROM projects WHERE repo_url = ?').get(repoUrl);
+    if (existing) {
+        db.prepare('UPDATE projects SET updated_at = ? WHERE id = ?').run(new Date().toISOString(), existing.id);
+        return existing.id;
+    }
+    // Create new project with repo URL as path (local_path set later)
+    const id = 'project:' + repoUrl;
+    const now = new Date().toISOString();
+    db.prepare('INSERT OR IGNORE INTO projects (id, path, repo_url, local_path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)').run(id, repoUrl, repoUrl, null, now, now);
+    return id;
+}
+export function updateProjectLocalPath(projectId, localPath) {
+    db.prepare('UPDATE projects SET local_path = ?, updated_at = ? WHERE id = ?').run(localPath, new Date().toISOString(), projectId);
+}
+export function findProjectByRepo(repoUrl) {
+    const row = db.prepare('SELECT id, path, local_path FROM projects WHERE repo_url = ?').get(repoUrl);
+    return row ? { id: row.id, path: row.path, local_path: row.local_path } : null;
+}
+export function createSession(id, projectId) {
+    // Backfill-safe upsert: insert if missing, set project_id only when a project is
+    // provided AND the session currently has none (never null out an existing link).
+    db.prepare(`
+    INSERT INTO sessions (id, started_at, project_id) VALUES (?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      project_id = CASE
+        WHEN excluded.project_id IS NOT NULL THEN COALESCE(sessions.project_id, excluded.project_id)
+        ELSE sessions.project_id
+      END
+  `).run(id, new Date().toISOString(), projectId ?? null);
+}
+export function getDashboard() {
+    const projects = db.prepare(`
+    SELECT
+      p.id, p.path, p.repo_url, p.local_path,
+      COUNT(DISTINCT s.id) as session_count,
+      COALESCE(SUM(t.tokens_total), 0) as total_tokens,
+      COALESCE(SUM(t.ai_credits), 0) as total_credits,
+      MAX(s.started_at) as last_active_at
+    FROM projects p
+    LEFT JOIN sessions s ON s.project_id = p.id
+    LEFT JOIN traces t ON t.session_id = s.id
+    GROUP BY p.id
+    ORDER BY last_active_at DESC
+  `).all();
+    const totals = db.prepare(`
+    SELECT
+      (SELECT COUNT(*) FROM projects) as projects,
+      (SELECT COUNT(*) FROM sessions) as sessions,
+      COALESCE((SELECT SUM(tokens_total) FROM traces), 0) as tokens,
+      COALESCE((SELECT SUM(ai_credits) FROM traces), 0) as credits
+  `).get();
+    const enriched = projects.map(p => {
+        const lastSession = db.prepare(`
+      SELECT s.id,
+        COALESCE((SELECT SUM(tokens_total) FROM traces WHERE session_id = s.id), 0) as tokens,
+        COALESCE((SELECT SUM(ai_credits) FROM traces WHERE session_id = s.id), 0) as credits
+      FROM sessions s
+      WHERE s.project_id = ?
+      ORDER BY s.started_at DESC
+      LIMIT 1
+    `).get(p.id);
+        return {
+            id: p.id,
+            path: p.path,
+            repoUrl: p.repo_url,
+            localPath: p.local_path,
+            sessionCount: p.session_count || 0,
+            totalTokens: p.total_tokens || 0,
+            totalCredits: p.total_credits || 0,
+            lastActiveAt: p.last_active_at,
+            lastSession: lastSession ?? null,
+        };
+    });
+    return {
+        projects: enriched,
+        totals: {
+            projects: totals.projects,
+            sessions: totals.sessions,
+            tokens: totals.tokens,
+            credits: totals.credits,
+        },
+    };
 }
 export function upsertTrace(entry) {
     db.prepare(`
@@ -156,3 +271,51 @@ function rowToEntry(row) {
 export function deleteTrace(id) {
     db.prepare('DELETE FROM traces WHERE id = ?').run(id);
 }
+export function getProjectTraces(projectId, limit = 200) {
+    const rows = db.prepare(`
+    SELECT t.* FROM traces t
+    JOIN sessions s ON s.id = t.session_id
+    WHERE s.project_id = ?
+    ORDER BY t.date_time DESC
+    LIMIT ?
+  `).all(projectId, limit);
+    return rows.map((r) => rowToEntry(r));
+}
+export function getProjectSessionSummary(projectId) {
+    const stats = db.prepare(`
+    SELECT
+      COUNT(*) as entries,
+      SUM(t.tokens_input) as input,
+      SUM(t.tokens_output) as output,
+      SUM(t.tokens_cached) as cached,
+      SUM(t.tokens_reasoning) as reasoning,
+      SUM(t.tokens_written) as written,
+      SUM(t.tokens_total) as total,
+      SUM(t.ai_credits) as credits,
+      SUM(t.duration_ms) as duration,
+      SUM(t.skill_count) as skills,
+      SUM(t.agent_count) as agents,
+      SUM(t.mcp_count) as mcps
+    FROM traces t
+    JOIN sessions s ON s.id = t.session_id
+    WHERE s.project_id = ?
+  `).get(projectId);
+    return {
+        sessionId: projectId,
+        startedAt: '',
+        totalEntries: stats.entries || 0,
+        totalTokens: {
+            input: stats.input || 0,
+            output: stats.output || 0,
+            cached: stats.cached || 0,
+            reasoning: stats.reasoning || 0,
+            written: stats.written || 0,
+            total: stats.total || 0,
+        },
+        totalCredits: stats.credits || 0,
+        totalDurationMs: stats.duration || 0,
+        totalSkillCalls: stats.skills || 0,
+        totalAgentCalls: stats.agents || 0,
+        totalMcpCalls: stats.mcps || 0,
+    };
+}

package/dist/otlpReceiver.js

@@ -14,7 +14,7 @@
  *   chat <model> span attrs: same as above
  *   User message event: github.copilot.user.message
  */
-import { upsertTrace, createSession, deleteTrace } from './db.js';
+import { upsertTrace, createSession, deleteTrace, ensureProject, ensureProjectByRepo } from './db.js';
 import { traceEvents } from './proxy.js';
 // ── Helpers ───────────────────────────────────────────────────────────────────
 function getAttr(attrs, key) {
@@ -37,20 +37,35 @@ function nanoToIso(nano) {
     return new Date(nanoToMs(nano)).toISOString();
 }
 const inFlight = new Map(); // traceId → InFlight
-// Sessions we've created in DB (avoid duplicate createSession calls)
-const knownSessions = new Set();
-function ensureSession(sessionId) {
-    if (!knownSessions.has(sessionId)) {
-        createSession(sessionId);
-        knownSessions.add(sessionId);
+// Sessions are created lazily. Always upsert so project_id gets backfilled
+// when the session was created earlier without a project.
+function ensureSession(sessionId, projectId) {
+    createSession(sessionId, projectId);
+}
+// ── Project resolution ────────────────────────────────────────────────────────
+// Precedence: repo URL > working dir > default (CLI) project.
+// If none match, the session keeps no project (traces still appear on live page).
+function resolveProjectId(repoUrl, workingDir, defaultProjectId) {
+    if (repoUrl)
+        return ensureProjectByRepo(String(repoUrl));
+    if (workingDir)
+        return ensureProject(workingDir);
+    return defaultProjectId;
+}
+function detectWorkingDir(attrs) {
+    for (const key of ['process.working_directory', 'github.copilot.working_dir']) {
+        const v = getAttr(attrs, key);
+        if (v && String(v).trim())
+            return String(v).trim();
     }
+    return undefined;
 }
 // ── Process one batch of spans ────────────────────────────────────────────────
 // Track standalone chat entries so invoke_agent can replace them (multiple chat spans per traceId)
 const pendingChatIds = new Map(); // `chat:${traceId}` → list of entryIds
 // Buffer tool calls that arrive before invoke_agent
 const pendingToolCalls = new Map(); // traceId → tool calls
-function processSpans(spans, sessionId) {
+function processSpans(spans, sessionId, projectId, workingDir) {
     for (const span of spans) {
         // DEBUG — log raw span to stderr when COPILOT_TRACER_DEBUG=1
         if (process.env.COPILOT_TRACER_DEBUG === '1') {
@@ -65,6 +80,9 @@ function processSpans(spans, sessionId) {
             const startMs = nanoToMs(span.startTimeUnixNano);
             const endMs = nanoToMs(span.endTimeUnixNano);
             const durationMs = endMs - startMs;
+            // Extract repo URL for auto project detection
+            const repoUrl = getAttr(attrs, 'github.copilot.git.repository');
+            const resolvedProjectId = resolveProjectId(repoUrl, workingDir, projectId);
             // Extract prompt from gen_ai.input.messages (real attr name from copilot)
             let promptText = '';
             let responseText = '';
@@ -108,15 +126,14 @@ function processSpans(spans, sessionId) {
                                 return text.trim();
                             })
                                 .join(' ')
-                                .trim()
-                                .slice(0, 300);
+                                .trim();
                         }
                         else {
-                            promptText = (userMsg?.content ?? String(raw)).slice(0, 300);
+                            promptText = (userMsg?.content ?? String(raw)).trim();
                         }
                     }
                     catch {
-                        promptText = String(raw).slice(0, 300);
+                        promptText = String(raw).trim();
                     }
                 }
             }
@@ -214,7 +231,7 @@ function processSpans(spans, sessionId) {
                 inf.entry.mcpCount = mcps;
                 pendingToolCalls.delete(traceId);
             }
-            ensureSession(sessionId);
+            ensureSession(sessionId, resolvedProjectId);
             upsertTrace(entry);
             traceEvents.emit('trace:update', entry);
             traceEvents.emit('trace:done', entry);
@@ -277,7 +294,7 @@ function processSpans(spans, sessionId) {
                     skillCount: 0, agentCount: 0, mcpCount: 0,
                     status: 'done',
                 };
-                ensureSession(sessionId);
+                ensureSession(sessionId, resolveProjectId(getAttr(attrs, 'github.copilot.git.repository'), workingDir, projectId));
                 upsertTrace(entry);
                 const chatKey = `chat:${traceId}`;
                 const existing = pendingChatIds.get(chatKey) ?? [];
@@ -384,7 +401,7 @@ function detectToolType(name) {
     return 'builtin';
 }
 // ── Register OTLP HTTP routes on the Express app ──────────────────────────────
-export function registerOtlpRoutes(app, defaultSessionId) {
+export function registerOtlpRoutes(app, defaultSessionId, projectId) {
     // OTLP traces — copilot sends JSON (http/json protocol)
     // body already parsed by express.json() middleware registered before this call
     app.post('/v1/traces', (req, res) => {
@@ -397,8 +414,9 @@ export function registerOtlpRoutes(app, defaultSessionId) {
                     ?? getAttr(resAttrs, 'session.id')
                     ?? getAttr(resAttrs, 'github.copilot.conversation_id');
                 const sessionId = String(sessionFromOtel ?? defaultSessionId);
+                const workingDir = detectWorkingDir(resAttrs);
                 for (const ss of rs.scopeSpans ?? []) {
-                    processSpans(ss.spans ?? [], sessionId);
+                    processSpans(ss.spans ?? [], sessionId, projectId, workingDir);
                 }
             }
             res.status(200).json({ partialSuccess: {} });

package/dist/setup.js

@@ -22,6 +22,26 @@ function otelEnvBlock(port) {
         `export ${OTEL_ENDPOINT_KEY}=http://localhost:${port}`,
         `export ${OTEL_CONTENT_KEY}=true`,
         `export ${OTEL_ENABLED_KEY}=true`,
+        ``,
+        `# Tag every copilot prompt with the terminal folder it ran from, so the`,
+        `# tracer can attribute it to the right project. OTLP carries no working-dir,`,
+        `# so we inject it via OTEL_RESOURCE_ATTRIBUTES (percent-encoded).`,
+        `copilot() {`,
+        `  local _wd`,
+        `  if command -v python3 >/dev/null 2>&1; then`,
+        `    _wd="$(pwd | python3 -c 'import sys,urllib.parse;print(urllib.parse.quote(sys.stdin.read().strip(), safe="/"))')"`,
+        `  else`,
+        `    _wd="$(pwd)"`,
+        `  fi`,
+        `  if [ -n "\${OTEL_RESOURCE_ATTRIBUTES:-}" ]; then`,
+        `    # Drop any stale working_dir entry, then append the current folder`,
+        `    OTEL_RESOURCE_ATTRIBUTES="$(printf '%s' "\$OTEL_RESOURCE_ATTRIBUTES" | sed -E 's/(^|,)github\.copilot\.working_dir=[^,]*/\\1/g; s/^,//')"`,
+        `    [ -z "\$OTEL_RESOURCE_ATTRIBUTES" ] || OTEL_RESOURCE_ATTRIBUTES="\${OTEL_RESOURCE_ATTRIBUTES},"`,
+        `  fi`,
+        `  OTEL_RESOURCE_ATTRIBUTES="\${OTEL_RESOURCE_ATTRIBUTES}github.copilot.working_dir=\${_wd}"`,
+        `  export OTEL_RESOURCE_ATTRIBUTES`,
+        `  command copilot "\$@"`,
+        `}`,
         `# <<< copilot-tracer <<<`,
     ].join('\n');
 }
@@ -130,7 +150,7 @@ function patchVSCodeSettings(settingsPath, port) {
     return { action: wasSet ? 'updated' : 'added' };
 }
 // ── Main setup ────────────────────────────────────────────────────────────────
-export function runSetup(port) {
+export function runSetup(port, silent = false) {
     const CHECK = '✅';
     const WARN = '⚠️ ';
     const INFO = '📍';
@@ -174,11 +194,12 @@ export function runSetup(port) {
         if (result.action === 'added') {
             console.log(`\n${CHECK} Shell profile patched: ${label}`);
             console.log(`   ${ARROW} Added OTEL env vars (endpoint, content capture)`);
+            console.log(`   ${ARROW} Added copilot() wrapper — tags each prompt with the terminal folder`);
             console.log(`   ${ARROW} Run: source ${profilePath}`);
         }
         else if (result.action === 'updated') {
             console.log(`\n${CHECK} Shell profile updated: ${label}`);
-            console.log(`   ${ARROW} Updated port to ${port}`);
+            console.log(`   ${ARROW} Updated port to ${port} + copilot() wrapper`);
             console.log(`   ${ARROW} Run: source ${profilePath}`);
         }
         else {
@@ -211,14 +232,16 @@ export function runSetup(port) {
     process.env[OTEL_CONTENT_KEY] = 'true';
     process.env[OTEL_ENABLED_KEY] = 'true';
     // 6. Summary
-    const profileBase = profilePath ? path.basename(profilePath) : '.zshrc';
-    console.log('\n────────────────────────────────────────────────');
-    console.log('  One manual step required:\n');
-    console.log(`  source ~/${profileBase}`);
-    console.log(`  (opens a new terminal already? — env is already active there)`);
-    if (vscode.found)
-        console.log('\n  Restart VS Code once to pick up the new terminal env.');
-    console.log('\n  ✨ Starting tracer web UI now...');
-    console.log(`  Open: http://localhost:${port}/`);
-    console.log('────────────────────────────────────────────────\n');
+    if (!silent) {
+        const profileBase = profilePath ? path.basename(profilePath) : '.zshrc';
+        console.log('\n────────────────────────────────────────────────');
+        console.log('  One manual step required:\n');
+        console.log(`  source ~/${profileBase}`);
+        console.log(`  (opens a new terminal already? — env is already active there)`);
+        if (vscode.found)
+            console.log('\n  Restart VS Code once to pick up the new terminal env.');
+        console.log('\n  ✨ Starting tracer web UI now...');
+        console.log(`  Open: http://localhost:${port}/`);
+        console.log('────────────────────────────────────────────────\n');
+    }
 }

package/dist/webServer.js

@@ -3,11 +3,12 @@ import { createServer } from 'http';
 import { Server } from 'socket.io';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { getTraces, getTrace, getSessionSummary } from './db.js';
+import { execSync } from 'child_process';
+import { getTraces, getTrace, getSessionSummary, getDashboard, updateProjectLocalPath, getProjectTraces, getProjectSessionSummary } from './db.js';
 import { traceEvents } from './proxy.js';
 import { registerOtlpRoutes } from './otlpReceiver.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export function startWebServer(port = 4747, sessionId) {
+export function startWebServer(port = 4747, sessionId, projectId) {
     const app = express();
     const httpServer = createServer(app);
     const io = new Server(httpServer, { cors: { origin: '*' } });
@@ -15,13 +16,59 @@ export function startWebServer(port = 4747, sessionId) {
     app.use(express.static(path.join(__dirname, '../web')));
     // Register OTLP receiver routes
     app.use(express.json({ limit: '10mb' }));
-    registerOtlpRoutes(app, sessionId ?? 'default');
+    registerOtlpRoutes(app, sessionId ?? 'default', projectId);
     // API
     app.get('/api/traces', (req, res) => {
         const sid = req.query.sessionId || undefined; // undefined = all sessions
         const traces = getTraces(sid, 200);
         res.json(traces);
     });
+    app.post('/api/refine', async (req, res) => {
+        const { prompt } = req.body;
+        if (!prompt?.trim()) {
+            res.status(400).json({ error: 'prompt required' });
+            return;
+        }
+        const origTok = Math.ceil(prompt.trim().length / 4);
+        // Meta-prompt grounded in prompt engineering best practices (promptingguide.ai)
+        const metaPrompt = `You are a world-class prompt engineering expert. Rewrite the user prompt below using these techniques where applicable:
+1. Role grounding — prepend "You are a <expert role>" if no persona is set
+2. Imperative clarity — replace indirect/hedging phrases with direct imperatives (Explain / List / Generate / Analyze)
+3. Output format — specify format (JSON, markdown, numbered steps, bullet list) when missing
+4. Chain-of-thought — add "Think step by step." for multi-step reasoning or debugging tasks
+5. Remove noise — remove filler (please, could you, I want you to, thank you, if you don't mind, maybe, I think, kind of, sort of)
+6. Add constraints — specify language, length, audience, tone if not present
+7. Redundancy — collapse repeated or contradictory instructions
+
+Respond ONLY with a valid JSON object (no markdown, no code fences):
+{"optimized":"<rewritten prompt>","issues":[{"type":"warn","msg":"<what was wrong>"}],"techniques":["<applied>"]}
+
+Prompt to optimize:
+${prompt.trim()}`;
+        try {
+            const raw = execSync(`copilot -p ${JSON.stringify(metaPrompt)} --model claude-sonnet-4.6`, { timeout: 45000, encoding: 'utf8', maxBuffer: 2 * 1024 * 1024 });
+            // Strip copilot CLI chrome (trailing "Changes  +0 -0" line, ANSI codes)
+            const cleaned = raw
+                .replace(/\x1b\[[0-9;]*m/g, '') // ANSI
+                .replace(/\r/g, '')
+                .split('\n')
+                .filter(l => !/^Changes\s+\+\d/.test(l.trim()))
+                .join('\n')
+                .trim();
+            // Extract JSON — copilot may wrap with prose
+            const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+            if (!jsonMatch)
+                throw new Error('No JSON in response: ' + cleaned.slice(0, 200));
+            const result = JSON.parse(jsonMatch[0]);
+            const newTok = Math.ceil((result.optimized ?? '').length / 4);
+            const inputSavingPct = origTok > 0 ? Math.max(0, Math.round((1 - newTok / origTok) * 100)) : 0;
+            res.json({ ok: true, ...result, origTok, newTok, inputSavingPct });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ ok: false, error: msg });
+        }
+    });
     app.get('/api/traces/:id', (req, res) => {
         const trace = getTrace(req.params.id);
         if (!trace)
@@ -34,14 +81,45 @@ export function startWebServer(port = 4747, sessionId) {
             return res.json(null);
         res.json(getSessionSummary(sid));
     });
+    app.get('/api/dashboard', (_req, res) => {
+        res.json(getDashboard());
+    });
+    // Project registration — CLI registers its local path for a project
+    app.post('/api/projects', (req, res) => {
+        const { projectId, localPath } = req.body;
+        if (!projectId || !localPath) {
+            res.status(400).json({ error: 'projectId and localPath required' });
+            return;
+        }
+        updateProjectLocalPath(projectId, localPath);
+        res.json({ ok: true });
+    });
+    // Project-scoped traces
+    app.get('/api/projects/:id/traces', (req, res) => {
+        const traces = getProjectTraces(req.params.id, 200);
+        res.json(traces);
+    });
+    // Project-scoped summary
+    app.get('/api/projects/:id/summary', (req, res) => {
+        res.json(getProjectSessionSummary(req.params.id));
+    });
     // Socket.io — push real-time updates
     io.on('connection', (socket) => {
+        const projectId = socket.handshake.query.projectId;
         // Send current state on connect
-        const sid = sessionId;
-        socket.emit('init', {
-            traces: getTraces(sid, 200),
-            summary: sid ? getSessionSummary(sid) : null,
-        });
+        if (projectId) {
+            socket.emit('init', {
+                traces: getProjectTraces(projectId, 200),
+                summary: getProjectSessionSummary(projectId),
+            });
+        }
+        else {
+            const sid = sessionId;
+            socket.emit('init', {
+                traces: getTraces(sid, 200),
+                summary: sid ? getSessionSummary(sid) : null,
+            });
+        }
         const onUpdate = (entry) => socket.emit('trace:update', entry);
         const onDone = (entry) => socket.emit('trace:done', entry);
         traceEvents.on('trace:update', onUpdate);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "copilot-tracer",
-  "version": "1.0.3",
-  "description": "Real-time monitor and tracing tool for GitHub Copilot CLI — tracks tokens, AI credits, MCP/skill/agent calls with console and web UI",
+  "version": "1.0.5",
+  "description": "Real-time tracing and prompt-refinement companion for GitHub Copilot CLI and VS Code Copilot — tracks tokens, AI credits, tool calls, and refined prompts with console and web UI",
   "keywords": [
     "copilot",
     "github-copilot",