@smartmemory/compose 0.1.34-beta → 0.1.36-beta

package/lib/tracker/cli.js

@@ -0,0 +1,31 @@
+import { providerFor } from './factory.js';
+
+export async function runTrackerCli(cwd, argv) {
+  const sub = argv[0];
+
+  // Guard unknown/missing subcommand BEFORE touching providerFor (no I/O on bad input).
+  if (sub !== 'status' && sub !== 'sync') {
+    return { output: 'usage: compose tracker <status|sync>', exitCode: 1 };
+  }
+
+  const provider = await providerFor(cwd);
+
+  if (sub === 'status') {
+    const h = await provider.health();
+    const output = [
+      `tracker provider: ${h.provider}`,
+      `canonical: ${h.canonical}`,
+      `pendingOps: ${h.pendingOps}`,
+      `conflicts: ${h.conflicts}`,
+      `mixedSources: ${(h.mixedSources || []).join(', ') || '(none)'}`,
+    ].join('\n');
+    return { output, exitCode: 0 };
+  }
+
+  // sub === 'sync'
+  const r = await provider.sync();
+  return {
+    output: `sync: drained ${r.drained}, quarantined ${r.quarantined ?? 0}, pending ${r.pending ?? 0}`,
+    exitCode: 0,
+  };
+}

package/lib/tracker/factory.js

@@ -0,0 +1,93 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { LocalFileProvider } from './local-provider.js';
+import { TrackerConfigError } from './provider.js';
+
+function loadTrackerConfig(cwd) {
+  const p = join(cwd, '.compose/compose.json');
+  // Absent file → local default (valid, not misconfig).
+  if (!existsSync(p)) return { provider: 'local' };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(p, 'utf8'));
+  } catch (e) {
+    // File EXISTS but JSON is malformed → fail fast (never silently fall back;
+    // silent fallback would mask misconfig — design.md Error Handling).
+    throw new TrackerConfigError(
+      `compose: tracker config at ${p} contains invalid JSON — ${e.message}`
+    );
+  }
+  // Absent tracker key → local default (valid).
+  const tracker = parsed.tracker;
+  if (tracker === undefined || tracker === null) return { provider: 'local' };
+  // tracker key present but structurally invalid → fail fast.
+  if (typeof tracker !== 'object' || Array.isArray(tracker)) {
+    throw new TrackerConfigError(
+      `compose: tracker config at ${p} has a "tracker" key but it is not an object (got ${Array.isArray(tracker) ? 'array' : typeof tracker})`
+    );
+  }
+  return tracker;
+}
+
+const ENTITY_METHODS = {
+  JOURNAL: ['readJournal', 'writeJournalEntry'],
+  VISION: ['getVisionState', 'putVisionState'],
+};
+
+function withFallback(active, local) {
+  const caps = active.capabilities();
+  return new Proxy(active, {
+    get(target, prop, receiver) {
+      if (typeof prop !== 'string') return Reflect.get(target, prop, receiver);
+      for (const [cap, methods] of Object.entries(ENTITY_METHODS)) {
+        if (methods.includes(prop) && !caps.has(cap)) {
+          const fn = local[prop];
+          return typeof fn === 'function' ? fn.bind(local) : fn;
+        }
+      }
+      const v = target[prop];
+      return typeof v === 'function' ? v.bind(target) : v;
+    },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Test transport injection (TEST-ONLY — no production effect)
+// ---------------------------------------------------------------------------
+//
+// Tests that drive PRODUCTION entry points (writers) through a GitHub-configured
+// project need to inject a fixture transport WITHOUT modifying the on-disk config
+// (which can't hold a function). Call `setTestTransport(transport)` before
+// constructing the provider; call `clearTestTransport()` in afterEach.
+//
+// Production behavior: `_testTransport` is undefined by default → no effect.
+//
+let _testTransport = undefined;
+
+/**
+ * @param {object|null} transport - fixture transport for tests; null to clear.
+ */
+export function setTestTransport(transport) {
+  _testTransport = transport ?? undefined;
+}
+
+export function clearTestTransport() {
+  _testTransport = undefined;
+}
+
+export async function providerFor(cwd) {
+  const cfg = loadTrackerConfig(cwd);
+  const local = await new LocalFileProvider().init(cwd, {});
+  if (!cfg.provider || cfg.provider === 'local') return local;
+  if (cfg.provider === 'github') {
+    const { GitHubProvider } = await import('./github-provider.js');
+    // Merge in the test-only transport if one has been set via setTestTransport().
+    // In production _testTransport is undefined and cfg.github is passed as-is.
+    const ghCfg = _testTransport !== undefined
+      ? { ...(cfg.github ?? {}), _transport: _testTransport }
+      : (cfg.github ?? {});
+    const gh = await new GitHubProvider().init(cwd, ghCfg);
+    return withFallback(gh, local);
+  }
+  throw new TrackerConfigError(`unknown tracker provider "${cfg.provider}"`);
+}

package/lib/tracker/github-api.js

@@ -0,0 +1,115 @@
+import { execFileSync } from 'child_process';
+import { TrackerConfigError } from './provider.js';
+
+function resolveToken(auth = {}, noGhFallback = false) {
+  if (auth.token) return auth.token;
+  if (auth.tokenEnv && process.env[auth.tokenEnv]) return process.env[auth.tokenEnv];
+  if (noGhFallback) return null;
+  try { return execFileSync('gh', ['auth', 'token'], { encoding: 'utf8' }).trim() || null; }
+  catch { return null; }
+}
+
+export class GitHubApi {
+  constructor(cfg, transport = null) {
+    this.repo = cfg.repo;
+    if (!this.repo || !/^[^/]+\/[^/]+$/.test(this.repo)) {
+      throw new TrackerConfigError(`tracker.github.repo must be "owner/name" (got "${this.repo}")`);
+    }
+    this.token = resolveToken(cfg.auth, cfg.auth?._noGhFallback || cfg._noGhFallback);
+    if (!this.token) {
+      throw new TrackerConfigError('no GitHub token: set tracker.github.auth.tokenEnv or run `gh auth login`',
+        { missing: 'token' });
+    }
+    this.transport = transport;
+  }
+  async _req(method, path, body) {
+    if (this.transport) return this.transport.request(method, path, body);
+    const res = await fetch(`https://api.github.com${path}`, {
+      method, headers: { Authorization: `Bearer ${this.token}`, Accept: 'application/vnd.github+json' },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    const remainingHdr = res.headers.get('x-ratelimit-remaining');
+    const resetHdr = res.headers.get('x-ratelimit-reset');
+    if (res.status === 403 && remainingHdr !== null && Number(remainingHdr) === 0) {
+      const e = new Error('rate limited');
+      e.rateLimit = { resetMs: Number(resetHdr) * 1000 - Date.now() };
+      throw e;
+    }
+    return { status: res.status, body: await res.json().catch(() => ({})), headers: res.headers };
+  }
+  async createIssue({ title, body, labels }) {
+    const r = await this._req('POST', `/repos/${this.repo}/issues`, { title, body, labels });
+    return r.body;
+  }
+  async getIssue(number) { return (await this._req('GET', `/repos/${this.repo}/issues/${number}`)).body; }
+  async updateIssue(number, patch) { return (await this._req('PATCH', `/repos/${this.repo}/issues/${number}`, patch)).body; }
+  async searchFeatureIssues() {
+    return (await this._req('GET', `/search/issues?q=repo:${this.repo}+label:compose-feature`)).body.items ?? [];
+  }
+  async addIssueComment(number, body) {
+    return (await this._req('POST', `/repos/${this.repo}/issues/${number}/comments`, { body })).body;
+  }
+  async listIssueComments(number) {
+    return (await this._req('GET', `/repos/${this.repo}/issues/${number}/comments`)).body ?? [];
+  }
+  async graphql(query, variables) {
+    const r = await this._req('POST', '/graphql', { query, variables });
+    return { data: r.body?.data, errors: r.body?.errors };
+  }
+
+  /**
+   * GET /repos/:repo — lightweight probe to verify token has repo access.
+   * Returns { status, body }; does NOT throw on 4xx.
+   */
+  async getRepo() {
+    return this._req('GET', `/repos/${this.repo}`);
+  }
+
+  /**
+   * GET /repos/:repo/contents/:path?ref=:ref
+   * Returns { text, sha } where text is the decoded file content.
+   * If the file does not exist (404), returns { text: '', sha: null }.
+   */
+  async getContents(path, ref) {
+    const query = ref ? `?ref=${encodeURIComponent(ref)}` : '';
+    const r = await this._req('GET', `/repos/${this.repo}/contents/${path}${query}`);
+    if (r.status === 404) return { text: '', sha: null };
+    if (r.status !== 200) {
+      throw new Error(
+        `getContents ${path}@${ref}: HTTP ${r.status} ${JSON.stringify(r.body)?.slice(0, 200)}`
+      );
+    }
+    const content = r.body?.content ?? '';
+    // GitHub returns base64 with embedded newlines — strip them before decoding.
+    const text = Buffer.from(content.replace(/\n/g, ''), 'base64').toString('utf-8');
+    const sha = r.body?.sha ?? null;
+    return { text, sha };
+  }
+
+  /**
+   * PUT /repos/:repo/contents/:path
+   * Creates or updates a file.
+   * @param {string} path - File path in the repo
+   * @param {string} text - New file content (UTF-8)
+   * @param {{ sha: string|null, branch: string, message: string }} opts
+   *   sha: current blob SHA (omit or pass null to create a new file)
+   *   branch: target branch
+   *   message: commit message
+   * On 409 (SHA conflict / optimistic-lock failure) throws with e.shaConflict = true.
+   */
+  async putContents(path, text, { sha, branch, message }) {
+    const body = {
+      message,
+      content: Buffer.from(text, 'utf-8').toString('base64'),
+      branch,
+    };
+    if (sha) body.sha = sha;
+    const r = await this._req('PUT', `/repos/${this.repo}/contents/${path}`, body);
+    if (r.status === 409) {
+      const e = new Error(`putContents: SHA conflict for ${path}`);
+      e.shaConflict = true;
+      throw e;
+    }
+    return r.body;
+  }
+}