lastgen 1.2.0 → 1.3.0

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "lastgen",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Check if you started coding before or after AI agents",
   "type": "module",
   "bin": {
-    "lastgen": "./src/index.ts"
+    "lastgen": "./bin/lastgen"
   },
   "engines": {
     "node": ">=22.18.0"
   },
   "files": [
-    "src",
+    "dist",
+    "bin",
     "web/dist",
     "README.md"
   ],
@@ -21,8 +22,9 @@
     "format": "prettier --write src/",
     "format:check": "prettier --check src/",
     "test": "node --test src/**/*.test.ts",
+    "build": "tsdown",
     "start": "node src/index.ts",
-    "prepublishOnly": "cd web && npm ci && npm run build"
+    "prepublishOnly": "npm run build && cd web && npm ci && npm run build"
   },
   "keywords": [
     "developer",
@@ -54,6 +56,7 @@
     "eslint-plugin-prettier": "^5.5.5",
     "prettier": "^3.8.1",
     "semantic-release": "^25.0.3",
+    "tsdown": "^0.21.1",
     "typescript": "^5.8.0"
   }
 }

package/src/cli.ts

@@ -1,179 +0,0 @@
-/**
- * @fileoverview CLI argument parsing and command routing using built-in parseArgs.
- */
-
-import { parseArgs } from 'node:util';
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { fetchFirstCommit, fetchUser } from './core/github.ts';
-import { createCertificate } from './core/proof.ts';
-import { nodeHash } from './hash.ts';
-import { displayBadgeMarkdown, displayCertificate, displayJson, error, info } from './display.ts';
-import { verifyCertificate } from './verify-cli.ts';
-import { serve } from './serve.ts';
-
-function getVersion(): string {
-  try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const packagePath = join(__dirname, '..', 'package.json');
-    const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
-    return pkg.version ?? 'unknown';
-  } catch {
-    return 'unknown';
-  }
-}
-
-const HELP_BRIEF = `
-    _            _
-   | | __ _ ___ | |_  __ _  ___ _ __
-   | |/ _\` / __|| __/ _\` |/ _ \\ '_ \\
-   | | (_| \\__ \\| || (_| |  __/ | | |
-   |_|\\__,_|___/ \\__\\__, |\\___|_| |_|
-                     |___/
-  Check if you started coding before or after AI agents.
-
-  Usage:
-    lastgen <username>                Classify a GitHub user
-    lastgen verify <file.json>        Verify a saved certificate
-    lastgen serve [--port <port>]     Launch web UI
-
-  Options:
-    --token <token>       GitHub personal access token
-    --json                Output as JSON
-    --badge               Output as README badge markdown
-    --port <port>         Port for web UI (default: 3000)
-    --no-color            Disable colors
-    -h, --help            Show this help
-    -v, --version         Show version
-
-  Environment:
-    GITHUB_TOKEN          GitHub token (alternative to --token)
-    NO_COLOR              Disable colors (any value)
-
-  Examples:
-    npx lastgen torvalds
-    npx lastgen --json torvalds > proof.json
-    npx lastgen verify proof.json
-    npx lastgen --badge torvalds
-    npx lastgen serve
-`;
-
-interface CliOptions {
-  command: string;
-  target: string;
-  token?: string;
-  port: number;
-  json: boolean;
-  badge: boolean;
-  help: boolean;
-  version: boolean;
-}
-
-export function parseCli(argv: string[]): CliOptions {
-  const { values, positionals } = parseArgs({
-    args: argv,
-    options: {
-      token: { type: 'string' },
-      json: { type: 'boolean', default: false },
-      badge: { type: 'boolean', default: false },
-      port: { type: 'string' },
-      help: { type: 'boolean', short: 'h', default: false },
-      version: { type: 'boolean', short: 'v', default: false },
-      'no-color': { type: 'boolean', default: false },
-    },
-    allowPositionals: true,
-    strict: false,
-  });
-
-  const first = positionals[0] ?? '';
-  const isVerify = first === 'verify';
-  const isServe = first === 'serve';
-
-  return {
-    command: isVerify ? 'verify' : isServe ? 'serve' : first ? 'lookup' : '',
-    target: isVerify ? (positionals[1] ?? '') : first,
-    token: (values.token as string | undefined) ?? process.env['GITHUB_TOKEN'],
-    port: Number(values.port) || 3000,
-    json: Boolean(values.json),
-    badge: Boolean(values.badge),
-    help: Boolean(values.help),
-    version: Boolean(values.version),
-  };
-}
-
-export async function run(argv: string[]): Promise<void> {
-  const opts = parseCli(argv);
-
-  if (opts.version) {
-    process.stdout.write(`lastgen ${getVersion()}\n`);
-    return;
-  }
-
-  if (opts.help || !opts.command) {
-    process.stdout.write(HELP_BRIEF);
-    return;
-  }
-
-  switch (opts.command) {
-    case 'lookup': {
-      await handleLookup(opts);
-      break;
-    }
-    case 'verify': {
-      await handleVerify(opts);
-      break;
-    }
-    case 'serve': {
-      serve(opts.port);
-      break;
-    }
-    default: {
-      error(`Unknown command: ${opts.command}`);
-      process.stdout.write(HELP_BRIEF);
-      process.exitCode = 2;
-    }
-  }
-}
-
-async function handleLookup(opts: CliOptions): Promise<void> {
-  if (!opts.target) {
-    error('Username required. Usage: lastgen <username>');
-    process.exitCode = 2;
-    return;
-  }
-
-  if (!opts.json && !opts.badge) {
-    info(`Looking up ${opts.target} on GitHub...`);
-  }
-
-  const [user, firstCommit] = await Promise.all([
-    fetchUser(opts.target, opts.token),
-    fetchFirstCommit(opts.target, opts.token),
-  ]);
-
-  const cert = await createCertificate(nodeHash, user, firstCommit);
-
-  if (opts.badge) {
-    displayBadgeMarkdown(cert);
-  } else if (opts.json) {
-    displayJson(cert);
-  } else {
-    displayCertificate(cert);
-  }
-}
-
-async function handleVerify(opts: CliOptions): Promise<void> {
-  if (!opts.target) {
-    error('Certificate file required. Usage: lastgen verify <file.json>');
-    process.exitCode = 2;
-    return;
-  }
-
-  const valid = await verifyCertificate(opts.target, nodeHash, opts.token);
-  if (!valid) {
-    process.exitCode = 1;
-  }
-}

package/src/core/github.ts

@@ -1,177 +0,0 @@
-/**
- * @fileoverview GitHub API client using built-in fetch. Zero dependencies.
- */
-
-import type { GitHubUser, FirstCommit, CommitDetail } from './types.ts';
-import { CUTOFF_DATE } from './types.ts';
-
-const GITHUB_API = 'https://api.github.com';
-const USER_AGENT = 'lastgen';
-
-function buildHeaders(token?: string): Record<string, string> {
-  const headers: Record<string, string> = {
-    Accept: 'application/vnd.github.v3+json',
-    'User-Agent': USER_AGENT,
-  };
-  if (token) {
-    headers['Authorization'] = `token ${token}`;
-  }
-  return headers;
-}
-
-async function githubFetch(
-  url: string,
-  token?: string,
-  extraHeaders?: Record<string, string>,
-): Promise<Response> {
-  const response = await fetch(url, { headers: { ...buildHeaders(token), ...extraHeaders } });
-
-  if (response.status === 403) {
-    const remaining = response.headers.get('x-ratelimit-remaining');
-    if (remaining === '0') {
-      const resetTimestamp = response.headers.get('x-ratelimit-reset');
-      const resetDate = resetTimestamp
-        ? new Date(Number(resetTimestamp) * 1000).toLocaleTimeString()
-        : 'soon';
-      throw new Error(`GitHub API rate limit exceeded. Resets at ${resetDate}.`);
-    }
-  }
-
-  if (response.status === 404) {
-    const userMatch = url.match(/\/users\/([^/?]+)/);
-    if (userMatch?.[1]) {
-      throw new Error(
-        `GitHub user '${decodeURIComponent(userMatch[1])}' not found. Check the spelling?`,
-      );
-    }
-    throw new Error(`Not found: ${url}`);
-  }
-
-  if (!response.ok) {
-    throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
-  }
-
-  return response;
-}
-
-export async function fetchUser(username: string, token?: string): Promise<GitHubUser> {
-  const response = await githubFetch(`${GITHUB_API}/users/${encodeURIComponent(username)}`, token);
-  const data = (await response.json()) as Record<string, unknown>;
-
-  return {
-    login: data.login as string,
-    id: data.id as number,
-    name: (data.name as string | null) ?? null,
-    createdAt: data.created_at as string,
-  };
-}
-
-export async function fetchFirstCommit(
-  username: string,
-  token?: string,
-): Promise<FirstCommit | null> {
-  const commit = await searchFirstCommit(username, token);
-
-  if (commit?.repo) {
-    commit.repoCreatedAt = await fetchRepoCreatedAt(commit.repo, token);
-  }
-
-  return commit;
-}
-
-async function fetchRepoCreatedAt(
-  repoFullName: string,
-  token?: string,
-): Promise<string | undefined> {
-  try {
-    const response = await githubFetch(`${GITHUB_API}/repos/${repoFullName}`, token);
-    const data = (await response.json()) as Record<string, unknown>;
-    return (data.created_at as string | undefined) ?? undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-async function searchFirstCommitByQuery(
-  query: string,
-  token?: string,
-  order: 'asc' | 'desc' = 'asc',
-): Promise<FirstCommit | null> {
-  try {
-    const url = `${GITHUB_API}/search/commits?q=${encodeURIComponent(query)}&sort=committer-date&order=${order}&per_page=1`;
-    const response = await githubFetch(url, token, {
-      Accept: 'application/vnd.github.cloak-preview+json',
-    });
-
-    const data = (await response.json()) as Record<string, unknown>;
-    const items = data.items as Array<Record<string, unknown>> | undefined;
-    const item = items?.[0];
-    if (!item) return null;
-
-    const commit = item.commit as Record<string, unknown>;
-    const author = commit.author as Record<string, unknown>;
-    const commitCommitter = commit.committer as Record<string, unknown> | undefined;
-    const repo = item.repository as Record<string, unknown>;
-
-    return {
-      date: author.date as string,
-      repo: (repo.full_name as string) ?? '',
-      sha: item.sha as string,
-      message: ((commit.message as string) ?? '').split('\n')[0] ?? '',
-      committerDate: (commitCommitter?.date as string | undefined) ?? undefined,
-    };
-  } catch (err) {
-    if (err instanceof Error && err.message.includes('rate limit')) throw err;
-    return null;
-  }
-}
-
-async function searchFirstCommit(username: string, token?: string): Promise<FirstCommit | null> {
-  const cutoffDate = CUTOFF_DATE.slice(0, 10);
-
-  return (
-    (await searchFirstCommitByQuery(
-      `author:${username} user:${username} committer-date:<${cutoffDate}`,
-      token,
-      'desc',
-    )) ??
-    (await searchFirstCommitByQuery(
-      `author:${username} committer-date:<${cutoffDate}`,
-      token,
-      'desc',
-    )) ??
-    (await searchFirstCommitByQuery(`author:${username}`, token))
-  );
-}
-
-export async function fetchCommit(
-  repoFullName: string,
-  sha: string,
-  token?: string,
-): Promise<CommitDetail> {
-  const url = `${GITHUB_API}/repos/${repoFullName}/commits/${sha}`;
-  const response = await githubFetch(url, token);
-  const data = (await response.json()) as Record<string, unknown>;
-
-  const commit = data.commit as Record<string, unknown>;
-  const commitAuthor = commit.author as Record<string, unknown>;
-  const commitCommitter = commit.committer as Record<string, unknown> | undefined;
-  const verification = commit.verification as Record<string, unknown> | undefined;
-  const author = data.author as Record<string, unknown> | null;
-  const committer = data.committer as Record<string, unknown> | null;
-  const parents = data.parents as Array<unknown> | undefined;
-
-  return {
-    sha: data.sha as string,
-    authorLogin: (author?.login as string | undefined) ?? null,
-    committerLogin: (committer?.login as string | undefined) ?? null,
-    authorEmail: (commitAuthor.email as string | undefined) ?? null,
-    authorDate: (commitAuthor.date as string | undefined) ?? null,
-    committerDate: (commitCommitter?.date as string | undefined) ?? null,
-    authorId: (author?.id as number | undefined) ?? null,
-    verificationReason: (verification?.reason as string | undefined) ?? null,
-    isRootCommit: Array.isArray(parents) && parents.length === 0,
-    message: ((commit.message as string) ?? '').split('\n')[0] ?? '',
-    verified: Boolean(verification?.verified),
-  };
-}

package/src/core/proof.ts

@@ -1,111 +0,0 @@
-/**
- * @fileoverview Era classification, hashing, and certificate generation.
- * Platform-agnostic: hash function is injected via HashFn.
- */
-
-import type { Certificate, EraKey, FirstCommit, GitHubUser, HashFn } from './types.ts';
-
-import { CERTIFICATE_SALT, CERTIFICATE_VERSION, CUTOFF_DATE, THIRTY_DAYS_MS } from './types.ts';
-
-export function classifyEra(proofDate: string): EraKey {
-  const cutoff = new Date(CUTOFF_DATE).getTime();
-  const date = new Date(proofDate).getTime();
-  return date < cutoff ? 'LAST_GEN' : 'AI_NATIVE';
-}
-
-export function resolveProofDate(user: GitHubUser, firstCommit: FirstCommit | null): string {
-  if (!firstCommit) {
-    return new Date().toISOString();
-  }
-
-  const effectiveDate = getEffectiveCommitDate(firstCommit);
-  const commitTime = new Date(effectiveDate).getTime();
-  const accountTime = new Date(user.createdAt).getTime();
-  const repoTime = firstCommit.repoCreatedAt
-    ? new Date(firstCommit.repoCreatedAt).getTime()
-    : Infinity;
-
-  if (commitTime < repoTime) {
-    return firstCommit.repoCreatedAt ?? user.createdAt;
-  }
-
-  return commitTime < accountTime ? effectiveDate : user.createdAt;
-}
-
-function getEffectiveCommitDate(commit: FirstCommit): string {
-  if (!commit.committerDate) {
-    return commit.date;
-  }
-
-  const authorTime = new Date(commit.date).getTime();
-  const committerTime = new Date(commit.committerDate).getTime();
-
-  if (committerTime - authorTime > THIRTY_DAYS_MS) {
-    return commit.committerDate;
-  }
-
-  return commit.date;
-}
-
-export async function generateCertificateHash(
-  hashFn: HashFn,
-  username: string,
-  githubId: number,
-  proofDate: string,
-  era: EraKey,
-): Promise<string> {
-  const payload = JSON.stringify({
-    username,
-    githubId,
-    proofDate,
-    era,
-    salt: CERTIFICATE_SALT,
-  });
-
-  return hashFn(payload);
-}
-
-export function generateCertificateNumber(hash: string): string {
-  const prefix = hash.slice(0, 4).toUpperCase();
-  const numericPart = parseInt(hash.slice(4, 12), 16) % 1000000;
-  const padded = String(numericPart).padStart(6, '0');
-  return `LGC-${prefix}-${padded}`;
-}
-
-export async function createCertificate(
-  hashFn: HashFn,
-  user: GitHubUser,
-  firstCommit: FirstCommit | null,
-): Promise<Certificate> {
-  const proofDate = resolveProofDate(user, firstCommit);
-  const era = classifyEra(proofDate);
-  const hash = await generateCertificateHash(hashFn, user.login, user.id, proofDate, era);
-  const certificateNumber = generateCertificateNumber(hash);
-
-  return {
-    version: CERTIFICATE_VERSION,
-    type: 'LASTGEN_CERTIFICATE',
-    identity: {
-      username: user.login,
-      githubId: user.id,
-      name: user.name,
-    },
-    proof: {
-      accountCreated: user.createdAt,
-      firstCommit: firstCommit ?? {
-        date: user.createdAt,
-        repo: '',
-        sha: '',
-        message: '(no public commits found - using account creation date)',
-      },
-      proofDate,
-    },
-    era,
-    verification: {
-      hash: `sha256:${hash}`,
-      salt: CERTIFICATE_SALT,
-    },
-    certificateNumber,
-    issuedAt: new Date().toISOString(),
-  };
-}

package/src/core/types.ts

@@ -1,89 +0,0 @@
-/**
- * @fileoverview Shared interfaces, constants, and type definitions for lastgen.
- */
-
-export const CUTOFF_DATE = '2025-02-21T00:00:00Z';
-
-export const ERAS = {
-  LAST_GEN: {
-    title: 'Last Generation Coder',
-    description: 'Wrote code before AI agents shipped',
-  },
-  AI_NATIVE: {
-    title: 'AI Native Coder',
-    description: 'First verifiable commit after AI agents shipped',
-  },
-} as const;
-
-export type EraKey = keyof typeof ERAS;
-
-export const CERTIFICATE_VERSION = '1.0';
-export const CERTIFICATE_SALT = 'lastgen_v1';
-export const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
-
-export interface GitHubUser {
-  login: string;
-  id: number;
-  name: string | null;
-  createdAt: string;
-}
-
-export interface FirstCommit {
-  date: string;
-  repo: string;
-  sha: string;
-  message: string;
-  repoCreatedAt?: string;
-  committerDate?: string;
-}
-
-export interface CertificateIdentity {
-  username: string;
-  githubId: number;
-  name: string | null;
-}
-
-export interface CertificateProof {
-  accountCreated: string;
-  firstCommit: FirstCommit;
-  proofDate: string;
-}
-
-export interface CertificateVerification {
-  hash: string;
-  salt: string;
-}
-
-export interface Certificate {
-  version: string;
-  type: 'LASTGEN_CERTIFICATE';
-  identity: CertificateIdentity;
-  proof: CertificateProof;
-  era: EraKey;
-  verification: CertificateVerification;
-  certificateNumber: string;
-  issuedAt: string;
-}
-
-export interface CommitDetail {
-  sha: string;
-  authorLogin: string | null;
-  committerLogin: string | null;
-  authorEmail: string | null;
-  authorDate: string | null;
-  committerDate: string | null;
-  authorId: number | null;
-  verificationReason: string | null;
-  isRootCommit: boolean;
-  message: string;
-  verified: boolean;
-}
-
-export interface VerifyResult {
-  check: string;
-  passed: boolean;
-  detail: string;
-}
-
-/** Platform-agnostic SHA-256 hash function. */
-export type HashFn = (data: string) => Promise<string>;