bitgit 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,125 @@
+/**
+ * bit init — scaffold .bit.yaml + .well-known/path402.json
+ */
+
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { resolve, basename } from 'path';
+import { stringify as toYaml } from 'yaml';
+import { configPath, type BitConfig } from '../config.js';
+import * as readline from 'readline';
+
+function ask(prompt: string, defaultValue?: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  return new Promise((resolve) => {
+    rl.question(`${prompt}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+function detectProjectName(): string {
+  const cwd = process.cwd();
+
+  // Try package.json
+  const pkgPath = resolve(cwd, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      if (pkg.name) return pkg.name.replace(/^@[^/]+\//, '');
+    } catch {}
+  }
+
+  // Try git remote
+  try {
+    const remote = execSync('git remote get-url origin', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    const match = remote.match(/\/([^/]+?)(?:\.git)?$/);
+    if (match) return match[1];
+  } catch {}
+
+  // Fall back to directory name
+  return basename(cwd);
+}
+
+export async function init(): Promise<void> {
+  const cfgPath = configPath();
+  if (existsSync(cfgPath)) {
+    console.log('.bit.yaml already exists. Delete it first to re-initialize.');
+    return;
+  }
+
+  console.log('bit init — setting up Bitcoin config for this project\n');
+
+  const detectedName = detectProjectName();
+  const name = await ask('Project name', detectedName);
+  const domain = await ask('Domain (optional)');
+  const token = await ask('Token symbol (optional)');
+  const contentType = await ask('Content type (blog/repo/domain/custom)', 'blog') as BitConfig['content']['type'];
+  const source = await ask(
+    'Content source directory',
+    contentType === 'blog' ? 'content/blog/' : contentType === 'repo' ? '.' : '',
+  );
+  const format = await ask('Inscription format (bitcoin_schema/op_return)', 'bitcoin_schema') as BitConfig['content']['format'];
+
+  const config: BitConfig = {
+    project: {
+      name,
+      ...(domain ? { domain } : {}),
+      ...(token ? { token } : {}),
+    },
+    wallet: {
+      key_env: 'BOASE_TREASURY_PRIVATE_KEY',
+    },
+    content: {
+      type: contentType,
+      source,
+      format,
+      protocol: `${name}-${contentType}`,
+    },
+    db: {
+      supabase_url_env: 'NEXT_PUBLIC_SUPABASE_URL',
+      supabase_key_env: 'SUPABASE_SERVICE_ROLE_KEY',
+      version_table: 'blog_post_versions',
+    },
+    ...(domain
+      ? {
+          dns_dex: {
+            token_symbol: token ? `$${token}` : `$${domain}`,
+          },
+        }
+      : {}),
+  };
+
+  writeFileSync(cfgPath, toYaml(config), 'utf8');
+  console.log(`\nCreated ${cfgPath}`);
+
+  // Generate .well-known/path402.json
+  if (domain) {
+    const wellKnownDir = resolve(process.cwd(), 'public', '.well-known');
+    mkdirSync(wellKnownDir, { recursive: true });
+
+    const path402 = {
+      name,
+      domain,
+      token: token || undefined,
+      protocol: '$402',
+      endpoints: {
+        press: `https://${domain}/api/path402/press`,
+        discover: `https://${domain}/api/path402/discover`,
+      },
+    };
+
+    const wellKnownPath = resolve(wellKnownDir, 'path402.json');
+    writeFileSync(wellKnownPath, JSON.stringify(path402, null, 2), 'utf8');
+    console.log(`Created ${wellKnownPath}`);
+
+    // Print DNS records
+    console.log(`\nAdd these DNS TXT records for ${domain}:`);
+    console.log(`  _path402.${domain}  →  v=path402; endpoint=https://${domain}/api/path402`);
+    console.log(`  _dnsdex.${domain}   →  dnsdex-verify=pending`);
+  }
+
+  console.log('\nDone. Run `bit status` to verify, `bit push` to inscribe.');
+}

package/src/commands/push.ts

@@ -0,0 +1,267 @@
+/**
+ * bit push — git push + inscribe changed content on BSV
+ *
+ * 1. git push to remote (if commits to push)
+ * 2. Detect changes since last inscription (git diff)
+ * 3. Inscribe changed content on BSV
+ * 4. Update version chain in DB
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, relative } from 'path';
+import { createHash } from 'crypto';
+import { PrivateKey } from '@bsv/sdk';
+import { loadConfig, resolvePrivateKey } from '../config.js';
+import { fetchUtxos, type UTXO } from '../bsv/utxo.js';
+import { buildInscriptionTx } from '../bsv/tx.js';
+import { buildOpReturn, buildBitcoinSchema } from '../bsv/script.js';
+import { broadcast } from '../bsv/broadcast.js';
+import { getDb } from '../db.js';
+
+export async function push(args: string[]): Promise<void> {
+  const dryRun = args.includes('--dry-run');
+  const skipGit = args.includes('--skip-git');
+  const config = loadConfig();
+  const cwd = process.cwd();
+
+  console.log(`bit push — ${config.project.name}`);
+  if (dryRun) console.log('  (dry run — no transactions will be broadcast)\n');
+
+  // 1. Git push
+  if (!skipGit) {
+    try {
+      const status = execSync('git status --porcelain', { cwd, encoding: 'utf8' }).trim();
+      if (status) {
+        console.log('Warning: uncommitted changes exist. Pushing what is committed.\n');
+      }
+
+      // Check if there are commits to push
+      try {
+        const ahead = execSync('git rev-list --count @{upstream}..HEAD', {
+          cwd,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+
+        if (parseInt(ahead) > 0) {
+          console.log(`Pushing ${ahead} commit(s) to remote...`);
+          if (!dryRun) {
+            execSync('git push', { cwd, stdio: 'inherit' });
+          }
+          console.log();
+        } else {
+          console.log('Git: up to date with remote.\n');
+        }
+      } catch {
+        // No upstream tracking — skip git push
+        console.log('Git: no upstream branch. Skipping git push.\n');
+      }
+    } catch (err: any) {
+      console.log(`Git push failed: ${err.message}. Continuing with inscription.\n`);
+    }
+  }
+
+  // 2. Find changed content
+  const sourceDir = resolve(cwd, config.content.source);
+  if (!existsSync(sourceDir)) {
+    console.error(`Content source not found: ${config.content.source}`);
+    process.exit(1);
+  }
+
+  // Get last inscribed commit from DB (if configured)
+  let lastInscribedCommit: string | null = null;
+  let db;
+  try {
+    db = getDb(config);
+    const versionTable = config.db?.version_table || 'blog_post_versions';
+    const { data } = await db
+      .from(versionTable)
+      .select('content_hash, inscription_txid')
+      .eq('project', config.project.name)
+      .order('created_at', { ascending: false })
+      .limit(1)
+      .maybeSingle();
+
+    if (data?.inscription_txid) {
+      console.log(`Last inscription: ${data.inscription_txid}`);
+    }
+  } catch {
+    // DB not available — inscribe everything in source
+  }
+
+  // Find files to inscribe
+  let filesToInscribe: string[] = [];
+
+  try {
+    // Try git diff to find changes
+    const lastTag = execSync('git describe --tags --abbrev=0 2>/dev/null || echo ""', {
+      cwd,
+      encoding: 'utf8',
+    }).trim();
+
+    const diffBase = lastTag || 'HEAD~1';
+    const diff = execSync(`git diff --name-only ${diffBase} -- "${config.content.source}"`, {
+      cwd,
+      encoding: 'utf8',
+    }).trim();
+
+    if (diff) {
+      filesToInscribe = diff.split('\n').filter((f) => existsSync(resolve(cwd, f)));
+    }
+  } catch {
+    // No git history — fall through
+  }
+
+  // If no git diff results, use all files in source directory
+  if (filesToInscribe.length === 0) {
+    try {
+      const allFiles = execSync(`find "${sourceDir}" -type f -name "*.md" -o -name "*.json" | sort`, {
+        cwd,
+        encoding: 'utf8',
+      }).trim();
+      if (allFiles) {
+        filesToInscribe = allFiles.split('\n').map((f) => relative(cwd, f));
+      }
+    } catch {}
+  }
+
+  if (filesToInscribe.length === 0) {
+    console.log('No content files found to inscribe.');
+    return;
+  }
+
+  console.log(`Found ${filesToInscribe.length} file(s) to inscribe:`);
+  filesToInscribe.forEach((f) => console.log(`  ${f}`));
+  console.log();
+
+  if (dryRun) {
+    console.log('Dry run — skipping inscription.');
+    return;
+  }
+
+  // 3. Inscribe on BSV
+  const wif = resolvePrivateKey(config);
+  const privateKey = PrivateKey.fromWif(wif);
+  const address = privateKey.toPublicKey().toAddress();
+
+  console.log(`Treasury: ${address}`);
+
+  const utxos = await fetchUtxos(address);
+  if (utxos.length === 0) {
+    console.error('No UTXOs found. Fund the treasury address first.');
+    process.exit(1);
+  }
+
+  let currentUtxo = utxos[0];
+  let totalFees = 0;
+  const results: { file: string; txid: string }[] = [];
+
+  for (let i = 0; i < filesToInscribe.length; i++) {
+    const filePath = resolve(cwd, filesToInscribe[i]);
+    const content = readFileSync(filePath, 'utf8');
+    const contentHash = createHash('sha256').update(content).digest('hex');
+
+    console.log(`[${i + 1}/${filesToInscribe.length}] ${filesToInscribe[i]} (${content.length} bytes)`);
+
+    // Build OP_RETURN script based on format
+    let opReturnScript;
+    const payloadSize = content.length;
+
+    if (config.content.format === 'bitcoin_schema') {
+      const mapData: Record<string, string> = {
+        app: config.project.domain || config.project.name,
+        type: config.content.type,
+        file: filesToInscribe[i],
+        hash: contentHash,
+      };
+
+      // Extract slug from filename for blog posts
+      if (config.content.type === 'blog') {
+        const slug = filesToInscribe[i]
+          .replace(/^.*\//, '')
+          .replace(/\.md$/, '');
+        mapData.slug = slug;
+      }
+
+      opReturnScript = buildBitcoinSchema(
+        content,
+        content.endsWith('.json') ? 'application/json' : 'text/markdown',
+        mapData,
+        privateKey,
+      );
+    } else {
+      const payload = JSON.stringify({
+        protocol: config.content.protocol,
+        file: filesToInscribe[i],
+        hash: contentHash,
+        content,
+        timestamp: new Date().toISOString(),
+      });
+      opReturnScript = buildOpReturn(
+        config.content.protocol,
+        'application/json',
+        payload,
+      );
+    }
+
+    try {
+      const { tx, fee, changeSats } = await buildInscriptionTx({
+        privateKey,
+        utxo: currentUtxo,
+        opReturnScript,
+        payloadSize,
+      });
+
+      const rawTx = tx.toHex();
+      const txid = await broadcast(rawTx);
+
+      totalFees += fee;
+      results.push({ file: filesToInscribe[i], txid });
+
+      console.log(`  TXID: ${txid}`);
+      console.log(`  Fee: ${fee} sats | Remaining: ${changeSats} sats`);
+      console.log(`  https://whatsonchain.com/tx/${txid}`);
+
+      // 4. Update version chain in DB
+      if (db && config.db?.version_table) {
+        try {
+          await db.from(config.db.version_table).insert({
+            project: config.project.name,
+            file_path: filesToInscribe[i],
+            content_hash: contentHash,
+            inscription_txid: txid,
+            created_at: new Date().toISOString(),
+          });
+        } catch (dbErr: any) {
+          console.log(`  DB update failed: ${dbErr.message}`);
+        }
+      }
+
+      // Chain: use change output as next input
+      currentUtxo = {
+        txid,
+        vout: 1, // change is output index 1 (after OP_RETURN at 0)
+        satoshis: changeSats,
+        script: currentUtxo.script,
+      };
+
+      // Small delay for mempool propagation
+      if (i < filesToInscribe.length - 1) {
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    } catch (err: any) {
+      console.log(`  FAILED: ${err.message}`);
+    }
+  }
+
+  // Summary
+  console.log('\n' + '='.repeat(50));
+  console.log(`Inscribed: ${results.length}/${filesToInscribe.length} files`);
+  console.log(`Total fees: ${totalFees} sats`);
+
+  if (results.length > 0) {
+    console.log('\nInscriptions:');
+    results.forEach((r) => console.log(`  ${r.file} → ${r.txid}`));
+  }
+}

package/src/commands/register.ts

@@ -0,0 +1,151 @@
+/**
+ * bit register <domain> — inscribe a domain on DNS-DEX
+ */
+
+import { createHash } from 'crypto';
+import { PrivateKey } from '@bsv/sdk';
+import { loadConfig, resolvePrivateKey } from '../config.js';
+import { selectUtxo } from '../bsv/utxo.js';
+import { buildInscriptionTx } from '../bsv/tx.js';
+import { buildOpReturn } from '../bsv/script.js';
+import { broadcast } from '../bsv/broadcast.js';
+import { getDb } from '../db.js';
+
+export async function register(domain: string, args: string[]): Promise<void> {
+  const dryRun = args.includes('--dry-run');
+  const supply = parseInt(args.find((a) => a.startsWith('--supply='))?.split('=')[1] || '1000000000');
+  const category = args.find((a) => a.startsWith('--category='))?.split('=')[1] || 'other';
+
+  let config;
+  try {
+    config = loadConfig();
+  } catch {
+    // No config — use env vars directly
+    config = null;
+  }
+
+  console.log(`bit register — inscribing ${domain} on DNS-DEX`);
+  if (dryRun) console.log('  (dry run)\n');
+
+  const ts = new Date().toISOString();
+  const tick = `$${domain}`;
+
+  // In dry-run mode, skip key resolution if no key available
+  let wif: string | undefined;
+  let address = '(no key configured)';
+  try {
+    wif = config ? resolvePrivateKey(config) : (
+      process.env.BOASE_TREASURY_PRIVATE_KEY ||
+      process.env.BSV_PRIVATE_KEY ||
+      undefined
+    );
+    if (wif) {
+      const privateKey = PrivateKey.fromWif(wif);
+      address = privateKey.toPublicKey().toAddress();
+    }
+  } catch {}
+
+  if (!wif && !dryRun) {
+    console.error('No private key found. Set BOASE_TREASURY_PRIVATE_KEY.');
+    process.exit(1);
+  }
+
+  // Build DNS-DEX inscription document
+  const doc = {
+    p: 'dnsdex-domain',
+    v: '1.0',
+    op: 'mint',
+    tick,
+    domain,
+    supply,
+    owner: {
+      wallet: config?.dns_dex?.token_symbol || tick,
+      type: 'treasury_key',
+    },
+    x402: {
+      fee_cents: 1,
+      initial_price: 0,
+    },
+    meta: {
+      category,
+      description: `https://${domain}`,
+      timestamp: ts,
+    },
+    verification: {
+      method: 'treasury_key',
+      proof: createHash('sha256')
+        .update(`${domain}:${address}:${ts}`)
+        .digest('hex')
+        .slice(0, 32),
+      verified_at: ts,
+    },
+    platform: 'dns-dex.com',
+  };
+
+  const payload = JSON.stringify(doc);
+  const contentHash = createHash('sha256').update(payload).digest('hex');
+
+  console.log(`Treasury: ${address}`);
+  console.log(`Tick: ${tick} | Supply: ${supply.toLocaleString()} | Category: ${category}`);
+  console.log(`Payload: ${payload.length} bytes\n`);
+
+  if (dryRun) {
+    console.log('Dry run — would inscribe:');
+    console.log(JSON.stringify(doc, null, 2));
+    return;
+  }
+
+  const privateKey = PrivateKey.fromWif(wif!);
+
+  const utxo = await selectUtxo(address);
+  const opReturnScript = buildOpReturn('dnsdex-domain', 'application/json', payload);
+
+  const { tx, fee, changeSats } = await buildInscriptionTx({
+    privateKey,
+    utxo,
+    opReturnScript,
+    payloadSize: payload.length,
+  });
+
+  const txid = await broadcast(tx.toHex());
+  const origin = `${txid}_0`;
+  const inscriptionId = `${txid}i0`;
+
+  console.log('Domain inscribed on BSV!');
+  console.log(`  TXID:       ${txid}`);
+  console.log(`  Origin:     ${origin}`);
+  console.log(`  Fee:        ${fee} sats`);
+  console.log(`  Explorer:   https://whatsonchain.com/tx/${txid}`);
+  console.log(`  Ordinal:    https://1satordinals.com/inscription/${inscriptionId}`);
+
+  // Update DB
+  try {
+    const db = getDb(config || undefined);
+    const { error } = await db
+      .from('dnsdex_domains')
+      .upsert({
+        domain,
+        status: 'active',
+        bsv_txid: txid,
+        bsv_origin: origin,
+        inscription_id: inscriptionId,
+        content_hash: contentHash,
+        verification_method: 'treasury_key',
+        verified_at: ts,
+        updated_at: ts,
+      }, { onConflict: 'domain' });
+
+    if (error) {
+      console.log(`\nDB update failed: ${error.message}`);
+    } else {
+      console.log(`\nDB: ${domain} → active`);
+    }
+  } catch (err: any) {
+    console.log(`\nDB not available: ${err.message}`);
+  }
+
+  // Print DNS records to add
+  console.log(`\nAdd these DNS TXT records for ${domain}:`);
+  console.log(`  _dnsdex.${domain}              →  dnsdex-verify=${txid}`);
+  console.log(`  _dnsdex-verification.${domain}  →  ${doc.verification.proof}`);
+}

package/src/commands/status.ts

@@ -0,0 +1,148 @@
+/**
+ * bit status — show Bitcoin state for this project
+ */
+
+import { PrivateKey } from '@bsv/sdk';
+import { loadConfig, resolvePrivateKey } from '../config.js';
+import { fetchUtxos } from '../bsv/utxo.js';
+import { getDb } from '../db.js';
+
+export async function status(): Promise<void> {
+  const config = loadConfig();
+
+  console.log(`bit status — ${config.project.name}\n`);
+
+  // Wallet info
+  let address: string;
+  try {
+    const wif = resolvePrivateKey(config);
+    const privateKey = PrivateKey.fromWif(wif);
+    address = privateKey.toPublicKey().toAddress();
+
+    const utxos = await fetchUtxos(address);
+    const totalSats = utxos.reduce((sum, u) => sum + u.satoshis, 0);
+
+    console.log('Wallet:');
+    console.log(`  Address:  ${address}`);
+    console.log(`  UTXOs:    ${utxos.length}`);
+    console.log(`  Balance:  ${totalSats.toLocaleString()} sats`);
+    console.log();
+  } catch (err: any) {
+    console.log(`Wallet: not configured (${err.message})\n`);
+    address = '';
+  }
+
+  // Domain info
+  if (config.project.domain) {
+    console.log('Domain:');
+    console.log(`  Name:     ${config.project.domain}`);
+
+    // Check DNS-DEX registration
+    try {
+      const db = getDb(config);
+      const { data } = await db
+        .from('dnsdex_domains')
+        .select('status, bsv_txid, verified_at')
+        .eq('domain', config.project.domain)
+        .maybeSingle();
+
+      if (data) {
+        console.log(`  DNS-DEX:  ${data.status}`);
+        if (data.bsv_txid) {
+          console.log(`  TXID:     ${data.bsv_txid}`);
+          console.log(`  Explorer: https://whatsonchain.com/tx/${data.bsv_txid}`);
+        }
+      } else {
+        console.log('  DNS-DEX:  not registered');
+      }
+    } catch {
+      console.log('  DNS-DEX:  (DB not available)');
+    }
+
+    // Check DNS TXT records
+    try {
+      const { execSync } = await import('child_process');
+      const txt = execSync(`dig +short TXT _dnsdex.${config.project.domain} 2>/dev/null`, {
+        encoding: 'utf8',
+      }).trim();
+      console.log(`  DNS TXT:  ${txt || '(not set)'}`);
+    } catch {
+      console.log('  DNS TXT:  (could not resolve)');
+    }
+
+    console.log();
+  }
+
+  // Token info
+  if (config.project.token) {
+    console.log('Token:');
+    console.log(`  Symbol:   ${config.project.token}`);
+
+    try {
+      const db = getDb(config);
+      const { data } = await db
+        .from('path402_tokens')
+        .select('id, name, total_supply, current_supply, base_price_sats, deploy_txid')
+        .eq('symbol', config.project.token)
+        .maybeSingle();
+
+      if (data) {
+        console.log(`  Name:     ${data.name}`);
+        console.log(`  Supply:   ${data.current_supply}/${data.total_supply}`);
+        console.log(`  Price:    ${data.base_price_sats} sats`);
+        if (data.deploy_txid) {
+          console.log(`  On-chain: https://whatsonchain.com/tx/${data.deploy_txid}`);
+        }
+
+        // Holder count
+        const { count } = await db
+          .from('path402_holdings')
+          .select('*', { count: 'exact', head: true })
+          .eq('token_id', data.id)
+          .gt('balance', 0);
+
+        console.log(`  Holders:  ${count || 0}`);
+      } else {
+        console.log('  (not found in path402_tokens)');
+      }
+    } catch {
+      console.log('  (DB not available)');
+    }
+
+    console.log();
+  }
+
+  // Version chain
+  console.log('Version chain:');
+  try {
+    const db = getDb(config);
+    const versionTable = config.db?.version_table || 'blog_post_versions';
+    const { data, error } = await db
+      .from(versionTable)
+      .select('file_path, content_hash, inscription_txid, created_at')
+      .eq('project', config.project.name)
+      .order('created_at', { ascending: false })
+      .limit(5);
+
+    if (error) {
+      console.log(`  (query failed: ${error.message})`);
+    } else if (!data || data.length === 0) {
+      console.log('  No inscriptions yet. Run `bit push` to inscribe content.');
+    } else {
+      console.log(`  Latest ${data.length} inscription(s):`);
+      for (const row of data) {
+        const date = new Date(row.created_at).toISOString().split('T')[0];
+        console.log(`  ${date}  ${row.file_path || '(unknown)'}`);
+        console.log(`          ${row.inscription_txid}`);
+      }
+    }
+  } catch {
+    console.log('  (DB not available)');
+  }
+
+  // Content source
+  console.log(`\nConfig:`);
+  console.log(`  Source:   ${config.content.source}`);
+  console.log(`  Format:   ${config.content.format}`);
+  console.log(`  Protocol: ${config.content.protocol}`);
+}