Add local provider reader foundation

Author: TheKrush

.vscodeignore

@@ -21,3 +21,5 @@ assets/**
 !out/*.js.map
 !out/core/*.js
 !out/core/*.js.map
+!out/providers/*.js
+!out/providers/*.js.map

package.json

@@ -108,6 +108,7 @@
     "validate:install": "powershell -NoProfile -ExecutionPolicy Bypass -File ./tools/dev-validate-install.ps1",
     "validate:manifest": "node scripts/validate-extension-manifest.cjs",
     "smoke:core": "node scripts/smoke-core.cjs",
+    "smoke:providers": "node scripts/smoke-providers.cjs",
     "package": "npx --yes @vscode/vsce package --no-dependencies",
     "test": "node ./out/test/runTest.js"
   },

scripts/smoke-providers.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const assert = require('assert');
+
+const OUT = path.resolve(__dirname, '../out');
+
+const { ClaudeLocalReader } = require(path.join(OUT, 'providers/claudeLocal'));
+const { CodexLocalReader } = require(path.join(OUT, 'providers/codexLocal'));
+const { runEnabledReaders } = require(path.join(OUT, 'providers/readProviders'));
+const { formatRefreshSummary } = require(path.join(OUT, 'core/formatQuota'));
+
+let pass = 0;
+let fail = 0;
+
+async function test(name, fn) {
+  try {
+    await fn();
+    console.log(`  PASS  ${name}`);
+    pass++;
+  } catch (e) {
+    console.error(`  FAIL  ${name}: ${e.message}`);
+    fail++;
+  }
+}
+
+const ABSENT = path.join(os.tmpdir(), `pf-smoke-absent-${Date.now()}`);
+
+async function main() {
+  // --- ClaudeLocalReader ---
+
+  await test('ClaudeLocalReader: returns not-found for absent path', async () => {
+    const reader = new ClaudeLocalReader(ABSENT);
+    const result = await reader.read();
+    assert.strictEqual(result.providerId, 'claude');
+    assert.strictEqual(result.status, 'not-found');
+  });
+
+  await test('ClaudeLocalReader: providerId is claude', async () => {
+    const reader = new ClaudeLocalReader(ABSENT);
+    assert.strictEqual(reader.providerId, 'claude');
+  });
+
+  // --- CodexLocalReader ---
+
+  await test('CodexLocalReader: returns not-found for absent path', async () => {
+    const reader = new CodexLocalReader(ABSENT);
+    const result = await reader.read();
+    assert.strictEqual(result.providerId, 'codex');
+    assert.strictEqual(result.status, 'not-found');
+  });
+
+  await test('CodexLocalReader: providerId is codex', async () => {
+    const reader = new CodexLocalReader(ABSENT);
+    assert.strictEqual(reader.providerId, 'codex');
+  });
+
+  // --- runEnabledReaders ---
+
+  await test('runEnabledReaders: empty enabledProviders returns empty array', async () => {
+    const readers = [new ClaudeLocalReader(ABSENT), new CodexLocalReader(ABSENT)];
+    const results = await runEnabledReaders(readers, []);
+    assert.strictEqual(results.length, 0);
+  });
+
+  await test('runEnabledReaders: only enabled providers run', async () => {
+    const readers = [new ClaudeLocalReader(ABSENT), new CodexLocalReader(ABSENT)];
+    const results = await runEnabledReaders(readers, ['claude']);
+    assert.strictEqual(results.length, 1);
+    assert.strictEqual(results[0].providerId, 'claude');
+  });
+
+  await test('runEnabledReaders: unknown provider id is skipped', async () => {
+    const readers = [new ClaudeLocalReader(ABSENT)];
+    const results = await runEnabledReaders(readers, ['openai']);
+    assert.strictEqual(results.length, 0);
+  });
+
+  await test('runEnabledReaders: both providers run when both enabled', async () => {
+    const readers = [new ClaudeLocalReader(ABSENT), new CodexLocalReader(ABSENT)];
+    const results = await runEnabledReaders(readers, ['claude', 'codex']);
+    assert.strictEqual(results.length, 2);
+    const ids = results.map(r => r.providerId).sort();
+    assert.deepStrictEqual(ids, ['claude', 'codex']);
+  });
+
+  // --- formatRefreshSummary ---
+
+  await test('formatRefreshSummary: empty results returns no-providers message', async () => {
+    const s = formatRefreshSummary([]);
+    assert.ok(s.includes('no providers'), `expected "no providers" in "${s}"`);
+  });
+
+  await test('formatRefreshSummary: not-found includes label and "not found"', async () => {
+    const s = formatRefreshSummary([{ providerId: 'claude', status: 'not-found' }]);
+    assert.ok(s.includes('Claude'), `expected "Claude" in "${s}"`);
+    assert.ok(s.includes('not found'), `expected "not found" in "${s}"`);
+  });
+
+  await test('formatRefreshSummary: ok includes file count', async () => {
+    const s = formatRefreshSummary([{ providerId: 'claude', status: 'ok', filesFound: 5 }]);
+    assert.ok(s.includes('Claude'), `expected "Claude" in "${s}"`);
+    assert.ok(s.includes('5'), `expected "5" in "${s}"`);
+  });
+
+  await test('formatRefreshSummary: ok with 1 file uses singular', async () => {
+    const s = formatRefreshSummary([{ providerId: 'claude', status: 'ok', filesFound: 1 }]);
+    assert.ok(s.includes('1 session file'), `expected singular "1 session file" in "${s}"`);
+    assert.ok(!s.includes('1 session files'), `expected no plural "1 session files" in "${s}"`);
+  });
+
+  await test('formatRefreshSummary: no-data includes label and "no session files"', async () => {
+    const s = formatRefreshSummary([{ providerId: 'codex', status: 'no-data', filesFound: 0 }]);
+    assert.ok(s.includes('Codex'), `expected "Codex" in "${s}"`);
+    assert.ok(s.includes('no session files'), `expected "no session files" in "${s}"`);
+  });
+
+  await test('formatRefreshSummary: error includes label and "read error"', async () => {
+    const s = formatRefreshSummary([{ providerId: 'claude', status: 'error' }]);
+    assert.ok(s.includes('Claude'), `expected "Claude" in "${s}"`);
+    assert.ok(s.includes('read error'), `expected "read error" in "${s}"`);
+  });
+
+  await test('formatRefreshSummary: mixed states joined with " | "', async () => {
+    const s = formatRefreshSummary([
+      { providerId: 'claude', status: 'ok', filesFound: 3 },
+      { providerId: 'codex', status: 'not-found' },
+    ]);
+    assert.ok(s.includes(' | '), `expected " | " separator in "${s}"`);
+  });
+
+  console.log('');
+  console.log(`smoke-providers: ${pass} passed, ${fail} failed`);
+  if (fail > 0) {
+    process.exit(1);
+  }
+}
+
+main().catch(e => {
+  console.error('smoke-providers: fatal error:', e);
+  process.exit(1);
+});

src/core/formatQuota.ts

@@ -1,5 +1,6 @@
 import { PROVIDER_LABELS, ProviderId } from './providers';
 import { ProviderQuotaState } from './quotaTypes';
+import { ReadResult } from './providerReader';
 
 export function formatProviderText(state: ProviderQuotaState): string {
   const label = PROVIDER_LABELS[state.providerId as ProviderId] ?? state.providerId;
@@ -21,3 +22,27 @@ export function formatStatusBarText(states: ProviderQuotaState[]): string {
   }
   return `⛽ ${parts.join(' | ')}`;
 }
+
+export function formatRefreshSummary(results: ReadResult[]): string {
+  if (results.length === 0) {
+    return 'no providers enabled';
+  }
+  const parts = results.map(r => {
+    const label = PROVIDER_LABELS[r.providerId as ProviderId] ?? r.providerId;
+    switch (r.status) {
+      case 'ok': {
+        const n = r.filesFound ?? 0;
+        return `${label}: ${n} session file${n !== 1 ? 's' : ''}`;
+      }
+      case 'no-data':
+        return `${label}: no session files`;
+      case 'not-found':
+        return `${label}: not found`;
+      case 'error':
+        return `${label}: read error`;
+      default:
+        return `${label}: unknown`;
+    }
+  });
+  return parts.join(' | ');
+}

src/core/providerReader.ts

@@ -0,0 +1,13 @@
+export type ReadResultStatus = 'ok' | 'not-found' | 'no-data' | 'error';
+
+export interface ReadResult {
+  providerId: string;
+  status: ReadResultStatus;
+  filesFound?: number;
+  detail?: string;
+}
+
+export interface ProviderReader {
+  readonly providerId: string;
+  read(): Promise<ReadResult>;
+}

src/extension.ts

@@ -1,38 +1,67 @@
 import * as vscode from 'vscode';
 import { getConfig } from './config';
 import { getDataFolderUri } from './dataFolder';
-import { formatStatusBarText } from './core/formatQuota';
-import { ProviderQuotaState } from './core/quotaTypes';
+import { formatRefreshSummary, formatStatusBarText } from './core/formatQuota';
+import { ReadResult } from './core/providerReader';
+import { ProviderQuotaState, ProviderQuotaStatus } from './core/quotaTypes';
+import { ClaudeLocalReader } from './providers/claudeLocal';
+import { CodexLocalReader } from './providers/codexLocal';
+import { runEnabledReaders } from './providers/readProviders';
 
 let statusBarItem: vscode.StatusBarItem | undefined;
 
-function buildPlaceholderStates(enabledProviders: string[]): ProviderQuotaState[] {
-  return enabledProviders.map(id => ({ providerId: id, status: 'no-data' as const }));
+function resultToQuotaState(result: ReadResult): ProviderQuotaState {
+  const status: ProviderQuotaStatus = result.status === 'error' ? 'unknown' : 'no-data';
+  return { providerId: result.providerId, status };
 }
 
-function refreshStatusBar(): void {
+function initStatusBar(): void {
   if (!statusBarItem) {
     return;
   }
   const cfg = getConfig();
-  const states = buildPlaceholderStates(cfg.enabledProviders);
+  const states: ProviderQuotaState[] = cfg.enabledProviders.map(id => ({
+    providerId: id,
+    status: 'no-data' as const,
+  }));
   statusBarItem.text = formatStatusBarText(states);
-  statusBarItem.tooltip = 'PromptFuel — provider data not yet implemented';
+  statusBarItem.tooltip = 'PromptFuel — loading...';
+}
+
+async function runRefresh(): Promise<void> {
+  if (!statusBarItem) {
+    return;
+  }
+  const cfg = getConfig();
+  const readers = [new ClaudeLocalReader(), new CodexLocalReader()];
+
+  let results: ReadResult[];
+  try {
+    results = await runEnabledReaders(readers, cfg.enabledProviders);
+  } catch {
+    results = cfg.enabledProviders.map(id => ({ providerId: id, status: 'error' as const }));
+  }
+
+  const states = results.map(resultToQuotaState);
+  statusBarItem.text = formatStatusBarText(states);
+  statusBarItem.tooltip = 'PromptFuel — click to open dashboard';
+
+  const summary = formatRefreshSummary(results);
+  vscode.window.showInformationMessage(`PromptFuel: ${summary}`);
 }
 
 export function activate(context: vscode.ExtensionContext) {
   statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 10);
   statusBarItem.command = 'promptFuel.openDashboard';
   statusBarItem.show();
-  refreshStatusBar();
+  initStatusBar();
 
   const openDashboard = vscode.commands.registerCommand('promptFuel.openDashboard', () => {
     vscode.window.showInformationMessage('PromptFuel: Usage Dashboard — coming soon.');
   });
 
   const refresh = vscode.commands.registerCommand('promptFuel.refresh', () => {
-    refreshStatusBar();
-    vscode.window.showInformationMessage('PromptFuel: refreshed.');
+    void runRefresh();
   });
 
   const openDataFolder = vscode.commands.registerCommand('promptFuel.openDataFolder', () => {

src/providers/claudeLocal.ts

@@ -0,0 +1,57 @@
+import * as fsp from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { ProviderReader, ReadResult } from '../core/providerReader';
+
+export function defaultClaudeProjectsPath(): string {
+  return path.join(os.homedir(), '.claude', 'projects');
+}
+
+export class ClaudeLocalReader implements ProviderReader {
+  readonly providerId = 'claude';
+  private readonly projectsRoot: string;
+
+  constructor(projectsRoot?: string) {
+    this.projectsRoot = projectsRoot ?? defaultClaudeProjectsPath();
+  }
+
+  async read(): Promise<ReadResult> {
+    try {
+      await fsp.access(this.projectsRoot);
+    } catch {
+      return { providerId: 'claude', status: 'not-found' };
+    }
+
+    const count = await countJsonlFiles(this.projectsRoot, 4);
+    if (count === 0) {
+      return { providerId: 'claude', status: 'no-data', filesFound: 0 };
+    }
+    return { providerId: 'claude', status: 'ok', filesFound: count };
+  }
+}
+
+async function countJsonlFiles(root: string, maxDepth: number): Promise<number> {
+  let count = 0;
+
+  async function walk(dir: string, depth: number): Promise<void> {
+    if (depth > maxDepth) {
+      return;
+    }
+    let entries;
+    try {
+      entries = await fsp.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await walk(path.join(dir, entry.name), depth + 1);
+      } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+        count++;
+      }
+    }
+  }
+
+  await walk(root, 0);
+  return count;
+}