preclaim 0.1.0 → 0.1.1

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "preclaim",
-  "version": "0.1.0",
+  "version": "0.1.1",
+  "description": "AI File Coordination Layer — predictive file locking for AI coding agents",
   "type": "module",
   "bin": {
-    "preclaim": "./dist/index.js"
+    "preclaim": "dist/index.js"
   },
-  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",

package/.turbo/turbo-build.log

@@ -1,4 +0,0 @@
-
-> preclaim@0.1.0 build /Users/paulveth/projects/preclaim/packages/cli
-> tsc
-

package/src/commands/check.ts

@@ -1,28 +0,0 @@
-import { resolveContext } from '../lib/client-factory.js';
-
-export async function checkCommand(filePaths: string[]) {
-  if (filePaths.length === 0) {
-    console.error('Specify one or more file paths to check.');
-    process.exit(1);
-  }
-
-  const { client, config } = await resolveContext();
-
-  const result = await client.batchCheck({
-    project_id: config.projectId,
-    file_paths: filePaths,
-  });
-
-  if (result.error) {
-    console.error(`Failed to check: ${result.error}`);
-    process.exit(1);
-  }
-
-  for (const [path, lock] of Object.entries(result.data!.locks)) {
-    if (lock) {
-      console.log(`LOCKED  ${path}  (session: ${lock.session_id.slice(0, 8)}…  expires: ${new Date(lock.expires_at).toLocaleTimeString()})`);
-    } else {
-      console.log(`FREE    ${path}`);
-    }
-  }
-}

package/src/commands/config.ts

@@ -1,43 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import { findConfig, type PreclaimConfig } from '@preclaim/core';
-
-export async function configCommand(opts: { get?: string; set?: string }) {
-  const found = await findConfig();
-  if (!found) {
-    console.error('No .preclaim.json found. Run `preclaim init` first.');
-    process.exit(1);
-  }
-
-  if (opts.get) {
-    const value = found.config[opts.get as keyof PreclaimConfig];
-    console.log(JSON.stringify(value, null, 2));
-    return;
-  }
-
-  if (opts.set) {
-    const [key, ...rest] = opts.set.split('=');
-    const value = rest.join('=');
-
-    if (!key || !value) {
-      console.error('Usage: preclaim config --set key=value');
-      process.exit(1);
-    }
-
-    const raw = await readFile(found.configPath, 'utf-8');
-    const config = JSON.parse(raw) as Record<string, unknown>;
-
-    // Try to parse as JSON, fallback to string
-    try {
-      config[key] = JSON.parse(value);
-    } catch {
-      config[key] = value;
-    }
-
-    await writeFile(found.configPath, JSON.stringify(config, null, 2) + '\n');
-    console.log(`Set ${key} = ${JSON.stringify(config[key])}`);
-    return;
-  }
-
-  // No flags — show full config
-  console.log(JSON.stringify(found.config, null, 2));
-}

package/src/commands/init.ts

@@ -1,109 +0,0 @@
-import { writeFile, readFile } from 'node:fs/promises';
-import { join, basename } from 'node:path';
-import { defaultConfig, loadCredentials, PreclaimClient } from '@preclaim/core';
-import { loginCommand } from './login.js';
-
-const DEFAULT_BACKEND = 'https://preclaim.dev';
-
-export async function initCommand(opts: { backend?: string; projectId?: string }) {
-  const configPath = join(process.cwd(), '.preclaim.json');
-
-  // Check if already exists
-  try {
-    await readFile(configPath, 'utf-8');
-    console.log('.preclaim.json already exists. Use `preclaim config` to modify.');
-    return;
-  } catch {
-    // File doesn't exist, proceed
-  }
-
-  const backend = opts.backend ?? DEFAULT_BACKEND;
-
-  // If project ID provided directly, skip onboarding
-  if (opts.projectId) {
-    const config = defaultConfig(opts.projectId, backend);
-    await writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
-    console.log(`Created .preclaim.json (project: ${opts.projectId})`);
-    printNextSteps();
-    return;
-  }
-
-  // Check if logged in, if not: login first
-  let creds = await loadCredentials();
-  if (!creds) {
-    console.log('Not logged in. Starting authentication...\n');
-    await loginCommand();
-    creds = await loadCredentials();
-    if (!creds) {
-      console.error('Login failed. Please try again.');
-      process.exit(1);
-    }
-    console.log('');
-  }
-
-  // Derive project name from directory
-  const dirName = basename(process.cwd());
-  const projectSlug = dirName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
-  const projectName = dirName;
-
-  console.log(`Setting up Preclaim for "${projectName}"...`);
-
-  // Call onboard API
-  const client = new PreclaimClient({
-    baseUrl: backend,
-    accessToken: creds.accessToken,
-    timeoutMs: 10000,
-  });
-
-  const res = await fetch(`${backend}/api/v1/onboard`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${creds.accessToken}`,
-    },
-    body: JSON.stringify({
-      project_name: projectName,
-      project_slug: projectSlug,
-    }),
-  });
-
-  if (!res.ok) {
-    const body = await res.text();
-    console.error(`Failed to create project: ${body}`);
-    process.exit(1);
-  }
-
-  const { data } = await res.json() as { data: { project_id: string; org_id: string; already_existed: boolean } };
-
-  if (data.already_existed) {
-    console.log(`Project "${projectName}" already exists, using existing project.`);
-  } else {
-    console.log(`Project "${projectName}" created.`);
-  }
-
-  // Update credentials with org_id
-  if (creds.user.orgId !== data.org_id) {
-    creds.user.orgId = data.org_id;
-    const { getCredentialsPath } = await import('@preclaim/core');
-    const { writeFile: wf, mkdir } = await import('node:fs/promises');
-    const { dirname } = await import('node:path');
-    const credPath = getCredentialsPath();
-    await mkdir(dirname(credPath), { recursive: true });
-    await wf(credPath, JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 });
-  }
-
-  // Write config
-  const config = defaultConfig(data.project_id, backend);
-  await writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
-
-  console.log(`\nCreated .preclaim.json`);
-  printNextSteps();
-}
-
-function printNextSteps() {
-  console.log('');
-  console.log('Next steps:');
-  console.log('  1. preclaim install-hooks');
-  console.log('  2. Commit .preclaim.json to your repo');
-  console.log('  3. Open multiple Claude Code terminals — locks are automatic');
-}

package/src/commands/install-hooks.ts

@@ -1,72 +0,0 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-interface ClaudeSettings {
-  hooks?: Record<string, Array<{
-    matcher: string;
-    hooks: Array<{
-      type: string;
-      command: string;
-    }>;
-  }>>;
-}
-
-export async function installHooksCommand() {
-  const hooksDir = join(__dirname, '..', 'hooks');
-  const settingsDir = join(process.cwd(), '.claude');
-  const settingsPath = join(settingsDir, 'settings.json');
-
-  // Read existing settings or create new
-  let settings: ClaudeSettings = {};
-  try {
-    const raw = await readFile(settingsPath, 'utf-8');
-    settings = JSON.parse(raw);
-  } catch {
-    // File doesn't exist
-  }
-
-  settings.hooks = {
-    PreToolUse: [{
-      matcher: '',
-      hooks: [{
-        type: 'command',
-        command: `node ${join(hooksDir, 'pre-tool-use.js')}`,
-      }],
-    }],
-    PostToolUse: [{
-      matcher: '',
-      hooks: [{
-        type: 'command',
-        command: `node ${join(hooksDir, 'post-tool-use.js')}`,
-      }],
-    }],
-    Stop: [{
-      matcher: '',
-      hooks: [{
-        type: 'command',
-        command: `node ${join(hooksDir, 'stop.js')}`,
-      }],
-    }],
-    SessionStart: [{
-      matcher: '',
-      hooks: [{
-        type: 'command',
-        command: `node ${join(hooksDir, 'session-start.js')}`,
-      }],
-    }],
-  };
-
-  await mkdir(settingsDir, { recursive: true });
-  await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-
-  console.log('Claude Code hooks installed in .claude/settings.json');
-  console.log('');
-  console.log('Hooks configured:');
-  console.log('  - PreToolUse: file lock gatekeeper');
-  console.log('  - PostToolUse: commit detection → release locks');
-  console.log('  - Stop: session cleanup');
-  console.log('  - SessionStart: session registration + heartbeat');
-}

package/src/commands/lock.ts

@@ -1,30 +0,0 @@
-import { resolveContext } from '../lib/client-factory.js';
-
-export async function lockCommand(filePath: string, opts: { session?: string; ttl?: string }) {
-  const { client, config, credentials } = await resolveContext();
-  const sessionId = opts.session ?? `manual_${crypto.randomUUID().slice(0, 8)}`;
-  const ttl = opts.ttl ? parseInt(opts.ttl, 10) : config.ttl;
-
-  const result = await client.claimFile({
-    project_id: config.projectId,
-    file_path: filePath,
-    session_id: sessionId,
-    ttl_minutes: ttl,
-  });
-
-  if (result.error) {
-    console.error(`Failed to lock: ${result.error}`);
-    process.exit(1);
-  }
-
-  const data = result.data!;
-
-  if (data.status === 'acquired' || data.status === 'already_held') {
-    console.log(`Locked: ${filePath} (expires: ${new Date(data.expires_at!).toLocaleTimeString()})`);
-  } else if (data.status === 'conflict') {
-    console.error(`Conflict: ${filePath} is locked by session ${data.holder!.session_id.slice(0, 8)}…`);
-    console.error(`  Acquired: ${new Date(data.holder!.acquired_at).toLocaleTimeString()}`);
-    console.error(`  Expires:  ${new Date(data.holder!.expires_at).toLocaleTimeString()}`);
-    process.exit(1);
-  }
-}

package/src/commands/login.ts

@@ -1,120 +0,0 @@
-import { createServer, type Server } from 'node:http';
-import { writeFile, mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { getCredentialsPath, findConfig } from '@preclaim/core';
-
-const SUPABASE_URL = 'https://aawbukcvngdffueowjsa.supabase.co';
-const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFhd2J1a2N2bmdkZmZ1ZW93anNhIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzM3NjI2NTcsImV4cCI6MjA4OTMzODY1N30.pwAyjgnbdoZmmJdsG2jF0nbvT4hueb8UZvstsdYhFFs';
-
-export async function loginCommand() {
-  const server = createServer();
-
-  const port = await new Promise<number>((resolve) => {
-    server.listen(0, () => {
-      resolve((server.address() as { port: number }).port);
-    });
-  });
-
-  const redirectTo = `http://localhost:${port}/callback`;
-  const oauthUrl = `${SUPABASE_URL}/auth/v1/authorize?provider=github&redirect_to=${encodeURIComponent(redirectTo)}`;
-
-  console.log('Opening browser for GitHub authentication...');
-  console.log(`If browser doesn't open, visit:\n${oauthUrl}\n`);
-
-  const { exec } = await import('node:child_process');
-  const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-  exec(`${openCmd} "${oauthUrl}"`);
-
-  await handleAuthCallback(server);
-}
-
-function handleAuthCallback(server: Server): Promise<void> {
-  return new Promise((resolve, reject) => {
-    server.on('request', async (req, res) => {
-      const url = new URL(req.url!, `http://localhost`);
-
-      if (url.pathname === '/callback') {
-        // Supabase implicit flow: tokens come in hash fragment.
-        // Serve a page that extracts them and POSTs to /token.
-        res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end(`<!DOCTYPE html><html><body>
-<h1>Logging in to Preclaim...</h1>
-<script>
-const hash = window.location.hash.substring(1);
-const params = new URLSearchParams(hash);
-const access_token = params.get('access_token');
-const refresh_token = params.get('refresh_token');
-const expires_in = params.get('expires_in');
-if (access_token) {
-  fetch('/token', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ access_token, refresh_token, expires_in })
-  }).then(() => {
-    document.body.innerHTML = '<h1>Logged in to Preclaim!</h1><p>You can close this tab.</p>';
-  });
-} else {
-  document.body.innerHTML = '<h1>Login failed</h1><p>No token received. Check the URL.</p>';
-}
-</script></body></html>`);
-        return;
-      }
-
-      if (url.pathname === '/token' && req.method === 'POST') {
-        let body = '';
-        req.on('data', (chunk: Buffer) => { body += chunk; });
-        req.on('end', async () => {
-          try {
-            const { access_token, refresh_token, expires_in } = JSON.parse(body);
-
-            // Get user info
-            const userRes = await fetch(`${SUPABASE_URL}/auth/v1/user`, {
-              headers: {
-                'Authorization': `Bearer ${access_token}`,
-                'apikey': SUPABASE_ANON_KEY,
-              },
-            });
-
-            if (!userRes.ok) throw new Error(`Failed to get user info: ${userRes.status}`);
-
-            const user = await userRes.json() as { id: string; email?: string };
-
-            // Save credentials
-            const credPath = getCredentialsPath();
-            await mkdir(dirname(credPath), { recursive: true });
-            await writeFile(credPath, JSON.stringify({
-              accessToken: access_token,
-              refreshToken: refresh_token,
-              expiresAt: new Date(Date.now() + parseInt(expires_in) * 1000).toISOString(),
-              user: {
-                id: user.id,
-                email: user.email ?? '',
-                orgId: '',
-              },
-            }, null, 2) + '\n', { mode: 0o600 });
-
-            res.writeHead(200);
-            res.end('ok');
-
-            console.log(`Logged in as ${user.email ?? user.id}`);
-            server.close();
-            resolve();
-          } catch (err) {
-            res.writeHead(500);
-            res.end('error');
-            console.error('Login failed:', err);
-            server.close();
-            reject(err);
-          }
-        });
-        return;
-      }
-    });
-
-    setTimeout(() => {
-      console.error('Login timed out.');
-      server.close();
-      process.exit(1);
-    }, 120_000);
-  });
-}

package/src/commands/status.ts

@@ -1,15 +0,0 @@
-import { resolveContext } from '../lib/client-factory.js';
-import { formatLockTable } from '../lib/output.js';
-
-export async function statusCommand() {
-  const { client, config } = await resolveContext();
-
-  const result = await client.listLocks(config.projectId);
-
-  if (result.error) {
-    console.error(`Failed to fetch status: ${result.error}`);
-    process.exit(1);
-  }
-
-  console.log(formatLockTable(result.data!));
-}

package/src/commands/unlock.ts

@@ -1,25 +0,0 @@
-import { resolveContext } from '../lib/client-factory.js';
-
-export async function unlockCommand(filePath: string | undefined, opts: { session?: string; all?: boolean }) {
-  const { client, config } = await resolveContext();
-
-  if (!filePath && !opts.all) {
-    console.error('Specify a file path or use --all to release all locks.');
-    process.exit(1);
-  }
-
-  const sessionId = opts.session ?? `manual_${crypto.randomUUID().slice(0, 8)}`;
-
-  const result = await client.releaseLocks({
-    project_id: config.projectId,
-    file_path: filePath,
-    session_id: sessionId,
-  });
-
-  if (result.error) {
-    console.error(`Failed to unlock: ${result.error}`);
-    process.exit(1);
-  }
-
-  console.log(`Released ${result.data!.released} lock(s).`);
-}

package/src/commands/whoami.ts

@@ -1,15 +0,0 @@
-import { loadCredentials } from '@preclaim/core';
-
-export async function whoamiCommand() {
-  const creds = await loadCredentials();
-
-  if (!creds) {
-    console.log('Not logged in. Run `preclaim login` to authenticate.');
-    return;
-  }
-
-  console.log(`Email:  ${creds.user.email}`);
-  console.log(`User:   ${creds.user.id}`);
-  console.log(`Org:    ${creds.user.orgId ?? 'none'}`);
-  console.log(`Expires: ${new Date(creds.expiresAt).toLocaleString()}`);
-}

package/src/hooks/heartbeat-daemon.ts

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-// Heartbeat daemon — runs as detached background process
-// Extends TTL on all session locks every 60s
-
-import { PreclaimClient } from '@preclaim/core';
-
-const sessionId = process.env.PRECLAIM_SESSION_ID;
-const backend = process.env.PRECLAIM_BACKEND;
-const accessToken = process.env.PRECLAIM_ACCESS_TOKEN;
-
-if (!sessionId || !backend || !accessToken) {
-  process.exit(1);
-}
-
-const client = new PreclaimClient({
-  baseUrl: backend,
-  accessToken,
-  timeoutMs: 5000,
-});
-
-const INTERVAL_MS = 60_000;
-const MAX_FAILURES = 5;
-let failures = 0;
-
-async function heartbeat() {
-  const result = await client.heartbeat({ session_id: sessionId! });
-
-  if (result.error) {
-    failures++;
-    if (failures >= MAX_FAILURES) {
-      process.exit(1);
-    }
-  } else {
-    failures = 0;
-  }
-}
-
-// Run immediately, then every 60s
-heartbeat();
-const interval = setInterval(heartbeat, INTERVAL_MS);
-
-// Cleanup on signals
-function shutdown() {
-  clearInterval(interval);
-  process.exit(0);
-}
-
-process.on('SIGTERM', shutdown);
-process.on('SIGINT', shutdown);

package/src/hooks/post-tool-use.ts

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-// PostToolUse hook — commit detection
-// Detects git commit commands and releases all session locks
-
-import { PreclaimClient, findConfig, loadCredentials } from '@preclaim/core';
-import { readHookInput } from '../lib/hook-io.js';
-
-async function main() {
-  try {
-    const input = await readHookInput();
-
-    // Only match Bash tool calls
-    if (input.tool_name !== 'Bash') return;
-
-    const command = input.tool_input?.command as string | undefined;
-    if (!command) return;
-
-    // Detect git commit (not amend, not just `git commit --help`)
-    const isCommit = /\bgit\s+commit\b/.test(command) && !/--help/.test(command);
-    if (!isCommit) return;
-
-    const found = await findConfig();
-    if (!found) return;
-
-    const creds = await loadCredentials();
-    if (!creds) return;
-
-    const client = new PreclaimClient({
-      baseUrl: found.config.backend,
-      accessToken: creds.accessToken,
-      timeoutMs: 3000,
-    });
-
-    // Release all locks for this session
-    await client.releaseLocks({
-      project_id: found.config.projectId,
-      session_id: input.session_id,
-    });
-  } catch {
-    // Silent fail — non-critical
-  }
-}
-
-main();

package/src/hooks/pre-tool-use.ts

@@ -1,110 +0,0 @@
-#!/usr/bin/env node
-// PreToolUse hook — the gatekeeper
-// Intercepts Edit/Write/MultiEdit tool calls, claims file locks
-
-import { PreclaimClient, findConfig, loadCredentials } from '@preclaim/core';
-import { readHookInput, writeHookOutput } from '../lib/hook-io.js';
-import { minimatch } from 'minimatch';
-
-const WRITE_TOOLS = new Set(['Edit', 'Write', 'MultiEdit']);
-
-async function main() {
-  try {
-    const input = await readHookInput();
-
-    // Only intercept file-writing tools
-    if (!input.tool_name || !WRITE_TOOLS.has(input.tool_name)) {
-      return; // No output = allow
-    }
-
-    // Extract file path from tool input
-    const filePath = input.tool_input?.file_path as string | undefined;
-    if (!filePath) {
-      return; // No file path = allow
-    }
-
-    // Load config
-    const found = await findConfig();
-    if (!found) {
-      return; // No config = allow (not a preclaim project)
-    }
-
-    // Check ignore patterns
-    const relativePath = filePath.startsWith('/') ? filePath : filePath;
-    if (found.config.ignore.some(pattern => minimatch(relativePath, pattern))) {
-      return; // Ignored file = allow
-    }
-
-    // Load credentials
-    const creds = await loadCredentials();
-    if (!creds) {
-      if (found.config.failOpen) return;
-      writeHookOutput({
-        permissionDecision: 'deny',
-        reason: 'Preclaim: not authenticated. Run `preclaim login`.',
-      });
-      return;
-    }
-
-    // Claim file
-    const client = new PreclaimClient({
-      baseUrl: found.config.backend,
-      accessToken: creds.accessToken,
-      timeoutMs: 2000, // Must be fast
-    });
-
-    const result = await client.claimFile({
-      project_id: found.config.projectId,
-      file_path: relativePath,
-      session_id: input.session_id,
-      ttl_minutes: found.config.ttl,
-    });
-
-    // Network error — fail open
-    if (result.error) {
-      if (found.config.failOpen) {
-        writeHookOutput({
-          permissionDecision: 'allow',
-          systemMessage: `[Preclaim] Warning: could not reach server (${result.error}). Proceeding without lock.`,
-        });
-        return;
-      }
-      writeHookOutput({
-        permissionDecision: 'deny',
-        reason: `Preclaim: server error — ${result.error}`,
-      });
-      return;
-    }
-
-    const data = result.data!;
-
-    if (data.status === 'acquired') {
-      writeHookOutput({
-        permissionDecision: 'allow',
-        systemMessage: `[Preclaim] Locked: ${relativePath} (expires: ${data.expires_at})`,
-      });
-    } else if (data.status === 'already_held') {
-      writeHookOutput({
-        permissionDecision: 'allow',
-        systemMessage: `[Preclaim] Lock extended: ${relativePath} (expires: ${data.expires_at})`,
-      });
-    } else if (data.status === 'conflict') {
-      writeHookOutput({
-        permissionDecision: 'deny',
-        reason: [
-          `Preclaim: ${relativePath} is locked by another session.`,
-          `  Session: ${data.holder!.session_id.slice(0, 8)}…`,
-          `  Since: ${new Date(data.holder!.acquired_at).toLocaleTimeString()}`,
-          `  Expires: ${new Date(data.holder!.expires_at).toLocaleTimeString()}`,
-          '',
-          'Wait for the lock to expire or work on a different file.',
-        ].join('\n'),
-      });
-    }
-  } catch {
-    // Fail open — never block development
-    return;
-  }
-}
-
-main();

package/src/hooks/session-start.ts

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-// SessionStart hook — init
-// Registers session, starts heartbeat daemon, injects system message
-
-import { spawn } from 'node:child_process';
-import { writeFile } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { PreclaimClient, findConfig, loadCredentials } from '@preclaim/core';
-import { readHookInput, writeHookOutput } from '../lib/hook-io.js';
-
-async function main() {
-  try {
-    const input = await readHookInput();
-
-    const found = await findConfig();
-    if (!found) return;
-
-    const creds = await loadCredentials();
-    if (!creds) {
-      writeHookOutput({
-        systemMessage: '[Preclaim] Not authenticated. File locking disabled. Run `preclaim login` to enable.',
-      });
-      return;
-    }
-
-    const client = new PreclaimClient({
-      baseUrl: found.config.backend,
-      accessToken: creds.accessToken,
-      timeoutMs: 3000,
-    });
-
-    // Register session
-    const result = await client.registerSession({
-      session_id: input.session_id,
-      project_id: found.config.projectId,
-      provider: 'claude-code',
-    });
-
-    if (result.error) {
-      if (found.config.failOpen) {
-        writeHookOutput({
-          systemMessage: `[Preclaim] Warning: could not register session (${result.error}). File locking may not work.`,
-        });
-        return;
-      }
-    }
-
-    // Start heartbeat daemon
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    const heartbeatScript = join(__dirname, 'heartbeat-daemon.js');
-
-    const daemon = spawn('node', [heartbeatScript], {
-      detached: true,
-      stdio: 'ignore',
-      env: {
-        ...process.env,
-        PRECLAIM_SESSION_ID: input.session_id,
-        PRECLAIM_BACKEND: found.config.backend,
-        PRECLAIM_ACCESS_TOKEN: creds.accessToken,
-      },
-    });
-
-    daemon.unref();
-
-    // Save PID for cleanup
-    if (daemon.pid) {
-      await writeFile(join(process.cwd(), '.preclaim.pid'), String(daemon.pid));
-    }
-
-    writeHookOutput({
-      systemMessage: [
-        '[Preclaim] Session registered. File locking is active.',
-        '',
-        'Preclaim coordinates file access across multiple AI sessions:',
-        '- Files are automatically locked when you edit them',
-        '- Locks prevent other sessions from editing the same files',
-        '- Locks are released when you commit or this session ends',
-        '- If a lock is denied, work on a different file',
-      ].join('\n'),
-    });
-  } catch {
-    // Fail open
-  }
-}
-
-main();

package/src/hooks/stop.ts

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-// Stop hook — cleanup
-// Releases all locks and stops heartbeat daemon
-
-import { readFile, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import { PreclaimClient, findConfig, loadCredentials } from '@preclaim/core';
-import { readHookInput } from '../lib/hook-io.js';
-
-async function main() {
-  try {
-    const input = await readHookInput();
-
-    const found = await findConfig();
-    if (!found) return;
-
-    const creds = await loadCredentials();
-    if (!creds) return;
-
-    const client = new PreclaimClient({
-      baseUrl: found.config.backend,
-      accessToken: creds.accessToken,
-      timeoutMs: 3000,
-    });
-
-    // End session (releases all locks)
-    await client.endSession(input.session_id);
-
-    // Kill heartbeat daemon if running
-    const pidFile = join(process.cwd(), '.preclaim.pid');
-    try {
-      const pid = parseInt(await readFile(pidFile, 'utf-8'), 10);
-      process.kill(pid, 'SIGTERM');
-      await unlink(pidFile);
-    } catch {
-      // No daemon running or already stopped
-    }
-  } catch {
-    // Silent fail — cleanup is best-effort
-  }
-}
-
-main();

package/src/index.ts

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { initCommand } from './commands/init.js';
-import { loginCommand } from './commands/login.js';
-import { lockCommand } from './commands/lock.js';
-import { unlockCommand } from './commands/unlock.js';
-import { statusCommand } from './commands/status.js';
-import { checkCommand } from './commands/check.js';
-import { whoamiCommand } from './commands/whoami.js';
-import { configCommand } from './commands/config.js';
-import { installHooksCommand } from './commands/install-hooks.js';
-
-const program = new Command();
-
-program
-  .name('preclaim')
-  .description('AI File Coordination Layer — predictive file locking for AI coding agents')
-  .version('0.1.0');
-
-program
-  .command('init')
-  .description('Initialize Preclaim in the current project')
-  .option('--backend <url>', 'Backend URL', 'https://preclaim.vercel.app')
-  .option('--project-id <id>', 'Project ID')
-  .action(initCommand);
-
-program
-  .command('login')
-  .description('Authenticate with Preclaim')
-  .action(loginCommand);
-
-program
-  .command('lock <file>')
-  .description('Lock a file')
-  .option('-s, --session <id>', 'Session ID')
-  .option('-t, --ttl <minutes>', 'Lock TTL in minutes')
-  .action(lockCommand);
-
-program
-  .command('unlock [file]')
-  .description('Release a file lock')
-  .option('-s, --session <id>', 'Session ID')
-  .option('-a, --all', 'Release all locks for this session')
-  .action(unlockCommand);
-
-program
-  .command('status')
-  .description('Show active locks for this project')
-  .action(statusCommand);
-
-program
-  .command('check <files...>')
-  .description('Check lock status for files')
-  .action(checkCommand);
-
-program
-  .command('whoami')
-  .description('Show current user info')
-  .action(whoamiCommand);
-
-program
-  .command('config')
-  .description('View or modify project configuration')
-  .option('--get <key>', 'Get a config value')
-  .option('--set <key=value>', 'Set a config value')
-  .action(configCommand);
-
-program
-  .command('install-hooks')
-  .description('Install Claude Code hooks in the current project')
-  .action(installHooksCommand);
-
-program.parse();

package/src/lib/auth.ts

@@ -1,17 +0,0 @@
-import { loadCredentials, type PreclaimCredentials } from '@preclaim/core';
-
-export async function requireAuth(): Promise<PreclaimCredentials> {
-  const creds = await loadCredentials();
-  if (!creds) {
-    console.error('Not logged in. Run `preclaim login` first.');
-    process.exit(1);
-  }
-
-  // Check expiry
-  if (new Date(creds.expiresAt) < new Date()) {
-    console.error('Session expired. Run `preclaim login` to re-authenticate.');
-    process.exit(1);
-  }
-
-  return creds;
-}

package/src/lib/client-factory.ts

@@ -1,26 +0,0 @@
-import { PreclaimClient, findConfig, type PreclaimConfig, type PreclaimCredentials } from '@preclaim/core';
-import { requireAuth } from './auth.js';
-
-export interface ResolvedContext {
-  client: PreclaimClient;
-  config: PreclaimConfig;
-  credentials: PreclaimCredentials;
-}
-
-export async function resolveContext(): Promise<ResolvedContext> {
-  const credentials = await requireAuth();
-
-  const found = await findConfig();
-  if (!found) {
-    console.error('No .preclaim.json found. Run `preclaim init` in your project root.');
-    process.exit(1);
-  }
-
-  const client = new PreclaimClient({
-    baseUrl: found.config.backend,
-    accessToken: credentials.accessToken,
-    timeoutMs: 5000,
-  });
-
-  return { client, config: found.config, credentials };
-}

package/src/lib/hook-io.ts

@@ -1,37 +0,0 @@
-// Hook I/O helpers for Claude Code hooks
-// Reads hook input from stdin and writes hook output to stdout
-
-export interface ClaudeHookInput {
-  session_id: string;
-  tool_name?: string;
-  tool_input?: Record<string, unknown>;
-}
-
-export interface ClaudeHookOutput {
-  permissionDecision?: 'allow' | 'deny';
-  reason?: string;
-  systemMessage?: string;
-}
-
-export async function readHookInput(): Promise<ClaudeHookInput> {
-  return new Promise((resolve, reject) => {
-    let data = '';
-    process.stdin.setEncoding('utf-8');
-    process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => {
-      try {
-        resolve(JSON.parse(data));
-      } catch {
-        reject(new Error('Failed to parse hook input'));
-      }
-    });
-    process.stdin.on('error', reject);
-
-    // Timeout after 3s
-    setTimeout(() => reject(new Error('Hook input timeout')), 3000);
-  });
-}
-
-export function writeHookOutput(output: ClaudeHookOutput): void {
-  process.stdout.write(JSON.stringify(output));
-}

package/src/lib/output.ts

@@ -1,20 +0,0 @@
-import type { Lock } from '@preclaim/core';
-
-export function formatLock(lock: Lock): string {
-  const acquired = new Date(lock.acquired_at).toLocaleTimeString();
-  const expires = new Date(lock.expires_at).toLocaleTimeString();
-  return `  ${lock.file_path}  (session: ${lock.session_id.slice(0, 8)}…  acquired: ${acquired}  expires: ${expires})`;
-}
-
-export function formatLockTable(locks: Lock[]): string {
-  if (locks.length === 0) {
-    return 'No active locks.';
-  }
-
-  const lines = ['Active locks:', ''];
-  for (const lock of locks) {
-    lines.push(formatLock(lock));
-  }
-  lines.push('', `Total: ${locks.length} lock(s)`);
-  return lines.join('\n');
-}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"]
-}