litmus-cli 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litmus-cli",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "CLI tool for Litmus engineering assessments",
   "license": "MIT",
   "author": "elenazhao",

package/src/commands/init.ts

@@ -1,177 +0,0 @@
-import { createWriteStream, unlinkSync } from "fs"
-import { pipeline } from "stream/promises"
-import { Readable } from "stream"
-import path from "path"
-import os from "os"
-import chalk from "chalk"
-import ora from "ora"
-import { fetchInitMetadata, downloadZip } from "../lib/api.js"
-import { writeConfig } from "../lib/config.js"
-import { extractZip } from "../lib/extract.js"
-import { startTracker } from "../lib/tracker.js"
-import { detectProject } from "../utils/detect-project.js"
-import { fatal, success, info, warn, FALLBACK_URL } from "../utils/errors.js"
-import { execSync } from "child_process"
-
-const DEFAULT_API_BASE = process.env.LITMUS_API_URL || "https://www.litmus.build"
-
-export async function runInit(token: string): Promise<void> {
-  const apiBase = DEFAULT_API_BASE
-
-  // Step 1: Fetch metadata
-  const spinner = ora("Connecting to Litmus...").start()
-  let metadata: Awaited<ReturnType<typeof fetchInitMetadata>>
-
-  try {
-    metadata = await fetchInitMetadata(apiBase, token)
-    spinner.succeed("Connected")
-  } catch (err) {
-    spinner.fail("Connection failed")
-    const msg = err instanceof Error ? err.message : String(err)
-    fatal(msg, `Check your token and try again, or contact the company for help.`)
-  }
-
-  // Check for naming collision
-  const targetDir = path.resolve(process.cwd(), metadata.folderName)
-  const { existsSync } = await import("fs")
-  if (existsSync(targetDir)) {
-    fatal(
-      `Folder "${metadata.folderName}" already exists in this directory.`,
-      `Delete or rename it, then re-run litmus init with your token.`
-    )
-  }
-
-  // Print what we're setting up
-  console.log()
-  console.log(chalk.bold(`  ${metadata.assessmentName}`))
-  if (metadata.deadline) {
-    const deadline = new Date(metadata.deadline)
-    const hoursLeft = Math.max(
-      0,
-      Math.floor((deadline.getTime() - Date.now()) / (1000 * 60 * 60))
-    )
-    const deadlineStr = deadline.toLocaleString()
-    if (hoursLeft < 24) {
-      warn(`Deadline in ${hoursLeft} hours (${deadlineStr})`)
-    } else {
-      info(`Deadline: ${deadlineStr}`)
-    }
-  }
-  if (metadata.timeLimit) {
-    info(`Time limit: ${metadata.timeLimit} minutes`)
-  }
-  console.log()
-
-  // Step 2: Download ZIP to a temp file
-  const downloadSpinner = ora("Downloading assessment...").start()
-  const tmpZip = path.join(os.tmpdir(), `litmus-${Date.now()}.zip`)
-
-  try {
-    const zipResponse = await downloadZip(apiBase, token)
-    if (!zipResponse.body) {
-      throw new Error("Empty response from server")
-    }
-    const nodeStream = Readable.fromWeb(
-      zipResponse.body as Parameters<typeof Readable.fromWeb>[0]
-    )
-    await pipeline(nodeStream, createWriteStream(tmpZip))
-    downloadSpinner.succeed("Downloaded")
-  } catch (err) {
-    downloadSpinner.fail("Download failed")
-    const msg = err instanceof Error ? err.message : String(err)
-    fatal(msg, `Contact the company for help or visit ${FALLBACK_URL}.`)
-  }
-
-  // Step 3: Extract from temp file to target directory
-  const extractSpinner = ora(`Setting up ${metadata.folderName}/...`).start()
-
-  try {
-    await extractZip(tmpZip, targetDir)
-    extractSpinner.succeed(`Created ${chalk.bold(metadata.folderName)}/`)
-  } catch (err) {
-    extractSpinner.fail("Extraction failed")
-    const msg = err instanceof Error ? err.message : String(err)
-    fatal(msg, `Contact the company for help or visit ${FALLBACK_URL}.`)
-  } finally {
-    try { unlinkSync(tmpZip) } catch { /* cleanup */ }
-  }
-
-  // Step 4: Initialize git repo with initial commit
-  try {
-    execSync("git --version", { stdio: "pipe" })
-    try {
-      execSync("git init", { cwd: targetDir, stdio: "pipe" })
-      execSync("git add -A", { cwd: targetDir, stdio: "pipe" })
-      execSync(
-        "git commit -m \"Assessment: initial state\"",
-        { cwd: targetDir, stdio: "pipe" }
-      )
-    } catch {
-      warn("Git is installed but failed to initialize. Check your git config (user.name / user.email).")
-    }
-  } catch {
-    // git not installed — non-critical, analysis degrades gracefully
-  }
-
-  // Step 5: Write .litmus/config.json
-  await writeConfig(targetDir, {
-    assessmentId: metadata.assessmentId,
-    assessmentName: metadata.assessmentName,
-    candidateEmail: metadata.candidateEmail,
-    candidateName: metadata.candidateName,
-    token,
-    startedAt: metadata.startedAt,
-    deadline: metadata.deadline,
-    timeLimit: metadata.timeLimit,
-    apiBase,
-  })
-
-  // Step 5: Detect project type and optionally install
-  const project = detectProject(targetDir)
-  if (project.installCommand) {
-    console.log()
-    const installSpinner = ora(
-      `Running ${chalk.cyan(project.installCommand)}... (this may take a minute)`
-    ).start()
-    try {
-      execSync(project.installCommand, {
-        cwd: targetDir,
-        stdio: "pipe",
-      })
-      installSpinner.succeed("Dependencies installed")
-    } catch {
-      installSpinner.warn(
-        `Couldn't run "${project.installCommand}" automatically. Run it manually inside ${metadata.folderName}/.`
-      )
-    }
-  }
-
-  // Step 6: Start tracker in background
-  try {
-    startTracker(targetDir)
-  } catch {
-    // Non-critical
-  }
-
-  // Done — print next steps
-  console.log()
-  success("Assessment ready")
-  console.log()
-  console.log(chalk.bold("  Next steps:"))
-  console.log()
-  console.log(`    ${chalk.cyan(`cd ${metadata.folderName}`)}`)
-  console.log(`    ${chalk.dim("# Optional: open in a new window")}`)
-  console.log(`    ${chalk.cyan("code .")} ${chalk.dim("or")} ${chalk.cyan("cursor .")}`)
-  console.log()
-  console.log(chalk.dim("  Commit often to save your progress."))
-  console.log()
-  console.log(chalk.dim("  Your work is being tracked. When you're done:"))
-  console.log()
-  console.log(`    ${chalk.cyan("litmus submit")}`)
-  console.log()
-  if (metadata.deadline) {
-    const deadline = new Date(metadata.deadline)
-    console.log(chalk.dim(`  Deadline: ${deadline.toLocaleString()}`))
-    console.log()
-  }
-}

package/src/commands/status.ts

@@ -1,145 +0,0 @@
-import { existsSync, readFileSync, statSync, readdirSync } from "fs"
-import path from "path"
-import chalk from "chalk"
-import { readConfig, findProjectRoot } from "../lib/config.js"
-import { fatal, info } from "../utils/errors.js"
-import { execSync } from "child_process"
-
-export async function runStatus(): Promise<void> {
-  const config = await readConfig()
-
-  if (!config) {
-    fatal(
-      "No Litmus assessment found in this directory.",
-      "Run this command from inside your assessment folder, or run 'litmus init <token>' first."
-    )
-  }
-
-  const projectRoot = findProjectRoot() ?? process.cwd()
-  const folderName = path.basename(projectRoot)
-
-  console.log()
-  console.log(chalk.bold(`  ${config.assessmentName}`))
-  console.log()
-
-  // Candidate info
-  info(`  Candidate: ${config.candidateName} (${config.candidateEmail})`)
-  info(`  Folder: ${folderName}/`)
-
-  // Time elapsed since init
-  const startedAt = new Date(config.startedAt)
-  const elapsed = Date.now() - startedAt.getTime()
-  const elapsedHours = Math.floor(elapsed / (1000 * 60 * 60))
-  const elapsedMins = Math.floor((elapsed % (1000 * 60 * 60)) / (1000 * 60))
-  info(`  Started: ${startedAt.toLocaleString()} (${elapsedHours}h ${elapsedMins}m ago)`)
-
-  // Deadline / time remaining
-  if (config.deadline) {
-    const deadline = new Date(config.deadline)
-    const remaining = deadline.getTime() - Date.now()
-
-    if (remaining <= 0) {
-      console.log(chalk.red(`  Deadline: PASSED (${deadline.toLocaleString()})`))
-    } else {
-      const remHours = Math.floor(remaining / (1000 * 60 * 60))
-      const remMins = Math.floor((remaining % (1000 * 60 * 60)) / (1000 * 60))
-      info(`  Deadline: ${deadline.toLocaleString()} (${remHours}h ${remMins}m remaining)`)
-    }
-  }
-
-  if (config.timeLimit) {
-    const timeLimitMs = config.timeLimit * 60 * 1000
-    const used = Date.now() - startedAt.getTime()
-    const remaining = timeLimitMs - used
-    if (remaining <= 0) {
-      console.log(chalk.red(`  Time limit: EXCEEDED (${config.timeLimit} minutes)`))
-    } else {
-      const remMins = Math.floor(remaining / (1000 * 60))
-      info(`  Time limit: ${config.timeLimit} min (${remMins} min remaining)`)
-    }
-  }
-
-  console.log()
-
-  // Git stats
-  try {
-    execSync("git --version", { stdio: "pipe" })
-    try {
-      const commitCount = execSync("git rev-list --count HEAD", { cwd: projectRoot, stdio: "pipe" }).toString().trim()
-      const lastCommit = execSync("git log -1 --format=%s", { cwd: projectRoot, stdio: "pipe" }).toString().trim()
-      info(`  Commits: ${commitCount}`)
-      info(`  Last commit: "${lastCommit}"`)
-    } catch {
-      info(`  Commits: no commits yet`)
-    }
-  } catch {
-    info(`  Git: not installed`)
-  }
-
-  // Estimated submission size (count files, approximate size)
-  const sizeInfo = estimateSubmissionSize(projectRoot)
-  info(`  Files: ~${sizeInfo.fileCount}`)
-  info(`  Estimated submission size: ~${sizeInfo.sizeMb} MB`)
-
-  // Tracker status
-  const pidFile = path.join(projectRoot, ".litmus", "tracker.pid")
-  let trackerRunning = false
-  try {
-    const pid = parseInt(readFileSync(pidFile, "utf8").trim(), 10)
-    if (!isNaN(pid)) {
-      process.kill(pid, 0) // check if process exists (signal 0)
-      trackerRunning = true
-    }
-  } catch { /* not running */ }
-  info(`  Tracker: ${trackerRunning ? "running" : "not running"}`)
-
-  // Activity log stats
-  const activityPath = path.join(projectRoot, ".litmus", "activity.jsonl")
-  if (existsSync(activityPath)) {
-    try {
-      const content = readFileSync(activityPath, "utf8")
-      const lines = content.split("\n").filter(l => l.trim())
-      info(`  Activity events: ${lines.length}`)
-    } catch { /* ignore */ }
-  }
-
-  console.log()
-  console.log(chalk.dim("  When you're ready to submit:"))
-  console.log(`    ${chalk.cyan("litmus submit")}`)
-  console.log()
-}
-
-function estimateSubmissionSize(projectRoot: string): { fileCount: number; sizeMb: string } {
-  let fileCount = 0
-  let totalBytes = 0
-
-  const SKIP_DIRS = new Set([
-    "node_modules", "__pycache__", "venv", ".venv", "env", ".env",
-    "target", "build", "dist", ".gradle", ".idea",
-  ])
-
-  function walk(dir: string): void {
-    let entries: string[]
-    try {
-      entries = readdirSync(dir)
-    } catch {
-      return
-    }
-    for (const entry of entries) {
-      if (SKIP_DIRS.has(entry)) continue
-      const fullPath = path.join(dir, entry)
-      try {
-        const stat = statSync(fullPath)
-        if (stat.isDirectory()) {
-          walk(fullPath)
-        } else {
-          fileCount++
-          totalBytes += stat.size
-        }
-      } catch { /* permission errors, etc. */ }
-    }
-  }
-
-  walk(projectRoot)
-  return { fileCount, sizeMb: (totalBytes / (1024 * 1024)).toFixed(1) }
-}

package/src/commands/submit.ts

@@ -1,165 +0,0 @@
-import { statSync, unlinkSync, readFileSync } from "fs"
-import { rm } from "fs/promises"
-import path from "path"
-import chalk from "chalk"
-import ora from "ora"
-import * as readline from "readline/promises"
-import { stdin as input, stdout as output } from "process"
-import { readConfig, findProjectRoot } from "../lib/config.js"
-import { submitZip } from "../lib/api.js"
-import { createSubmissionZip } from "../lib/zip.js"
-import { fatal, success, warn, info, FALLBACK_URL } from "../utils/errors.js"
-
-export async function runSubmit(opts: { yes?: boolean }): Promise<void> {
-  // Step 1: Read config
-  const config = await readConfig()
-
-  if (!config) {
-    fatal(
-      "No Litmus assessment found in this directory.",
-      "Run this command from inside your assessment folder, or run 'litmus init <token>' first."
-    )
-  }
-
-  // Step 2: Check deadline
-  if (config.deadline) {
-    const deadline = new Date(config.deadline)
-    const now = new Date()
-
-    if (now > deadline) {
-      fatal(
-        `The submission deadline passed at ${deadline.toLocaleString()}.`,
-        `Contact the company if you need an extension. Visit ${FALLBACK_URL} for help.`
-      )
-    }
-
-    const minsLeft = Math.floor((deadline.getTime() - now.getTime()) / (1000 * 60))
-    if (minsLeft < 30) {
-      warn(`Only ${minsLeft} minutes left before the deadline!`)
-    }
-  }
-
-  // Step 3: Find the project root (where .litmus/config.json lives)
-  const projectRoot = findProjectRoot() ?? process.cwd()
-
-  // Step 4: Create the submission ZIP
-  const zipSpinner = ora("Preparing submission...").start()
-  let zipPath: string
-
-  try {
-    zipPath = await createSubmissionZip(projectRoot)
-    zipSpinner.succeed("Submission prepared")
-  } catch (err) {
-    zipSpinner.fail("Failed to create submission archive")
-    const msg = err instanceof Error ? err.message : String(err)
-    fatal(msg, `Contact the company for help or visit ${FALLBACK_URL}.`)
-  }
-
-  // Step 5: Show what's being submitted
-  const zipSizeMb = (statSync(zipPath).size / (1024 * 1024)).toFixed(1)
-  const folderName = path.basename(projectRoot)
-
-  console.log()
-  console.log(chalk.bold(`  Submitting: ${config.assessmentName}`))
-  info(`  Archive size: ${zipSizeMb} MB`)
-  info(`  Tracking log included`)
-  if (config.deadline) {
-    info(`  Deadline: ${new Date(config.deadline).toLocaleString()}`)
-  }
-  console.log()
-
-  // Step 6: Confirm (unless --yes flag)
-  if (!opts.yes) {
-    const rl = readline.createInterface({ input, output })
-    let answer: string
-    try {
-      answer = await rl.question(
-        chalk.bold("  Confirm submission? ") + chalk.dim("[Y/n] ")
-      )
-    } finally {
-      rl.close()
-    }
-
-    const confirmed = answer.trim().toLowerCase()
-    if (confirmed !== "" && confirmed !== "y" && confirmed !== "yes") {
-      console.log()
-      console.log(chalk.dim("  Submission cancelled. Your work is saved."))
-      console.log()
-      try { unlinkSync(zipPath) } catch { /* cleanup */ }
-      process.exit(0)
-    }
-  }
-
-  console.log()
-
-  // Step 7: Upload with progress
-  const uploadSpinner = ora("Uploading submission...").start()
-
-  try {
-    const fileName = `${folderName}_submission.zip`
-    const result = await submitZip(config.apiBase, config.token, zipPath, fileName, (uploaded, total) => {
-      const pct = Math.round((uploaded / total) * 100)
-      const uploadedMb = (uploaded / (1024 * 1024)).toFixed(1)
-      const totalMb = (total / (1024 * 1024)).toFixed(1)
-      uploadSpinner.text = `Uploading submission... ${uploadedMb}/${totalMb} MB (${pct}%)`
-    })
-    uploadSpinner.succeed("Submission received")
-
-    console.log()
-    success("You're done!")
-    console.log()
-    console.log(
-      chalk.dim("  The company will review your work and be in touch.")
-    )
-    if (result.submissionId) {
-      console.log(chalk.dim(`  Submission ID: ${result.submissionId}`))
-    }
-    console.log()
-
-    // Step 8: Delete assessment folder after successful submission
-    await deleteAssessmentFolder(projectRoot, config.token, folderName)
-  } catch (err) {
-    uploadSpinner.fail("Upload failed")
-    const msg = err instanceof Error ? err.message : String(err)
-    console.log()
-    fatal(
-      msg,
-      `Visit ${FALLBACK_URL} to upload manually, or contact the company for help.`
-    )
-  } finally {
-    // Clean up temp ZIP
-    try { unlinkSync(zipPath) } catch { /* cleanup */ }
-  }
-}
-
-async function deleteAssessmentFolder(projectRoot: string, token: string, folderName: string): Promise<void> {
-  // Safety check: verify this is actually a litmus assessment directory with matching token
-  try {
-    const configPath = path.join(projectRoot, ".litmus", "config.json")
-    const configData = JSON.parse(readFileSync(configPath, "utf8"))
-    if (configData.token !== token) {
-      warn(`Could not verify assessment folder. You can manually remove: ${projectRoot}`)
-      return
-    }
-  } catch {
-    warn(`Could not verify assessment folder. You can manually remove: ${projectRoot}`)
-    return
-  }
-
-  // Verified — proceed with deletion
-  try {
-    // Stop the background tracker process
-    const pidFile = path.join(projectRoot, ".litmus", "tracker.pid")
-    try {
-      const pid = parseInt(readFileSync(pidFile, "utf8").trim(), 10)
-      if (!isNaN(pid)) process.kill(pid)
-    } catch { /* tracker may not be running */ }
-
-    await rm(projectRoot, { recursive: true, force: true })
-    console.log(chalk.dim(`  Assessment folder deleted: ${folderName}`))
-    console.log(chalk.dim(`  You may need to \`cd\` to another directory.`))
-    console.log()
-  } catch {
-    warn(`Could not delete assessment folder. You can manually remove: ${projectRoot}`)
-  }
-}

package/src/index.ts

@@ -1,58 +0,0 @@
-#!/usr/bin/env node
-import { program } from "commander"
-import { runInit } from "./commands/init.js"
-import { runSubmit } from "./commands/submit.js"
-import { runStatus } from "./commands/status.js"
-
-import { readFileSync } from "fs"
-import { fileURLToPath } from "url"
-import { dirname, join } from "path"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"))
-const VERSION = pkg.version
-
-program
-  .name("litmus")
-  .description("Litmus engineering assessment CLI")
-  .version(VERSION)
-
-program
-  .command("init <token>")
-  .description("Download and set up a Litmus assessment")
-  .action(async (token: string) => {
-    try {
-      await runInit(token)
-    } catch (err) {
-      console.error(err instanceof Error ? err.message : String(err))
-      process.exit(1)
-    }
-  })
-
-program
-  .command("submit")
-  .description("Submit your completed assessment")
-  .option("-y, --yes", "Skip confirmation prompt")
-  .action(async (opts: { yes?: boolean }) => {
-    try {
-      await runSubmit(opts)
-    } catch (err) {
-      console.error(err instanceof Error ? err.message : String(err))
-      process.exit(1)
-    }
-  })
-
-program
-  .command("status")
-  .description("Show assessment status and stats")
-  .action(async () => {
-    try {
-      await runStatus()
-    } catch (err) {
-      console.error(err instanceof Error ? err.message : String(err))
-      process.exit(1)
-    }
-  })
-
-program.parse()

package/src/lib/api.ts

@@ -1,140 +0,0 @@
-import { createReadStream, statSync } from "fs"
-import { request as httpsRequest } from "https"
-import { request as httpRequest } from "http"
-
-export interface InitMetadata {
-  assessmentId: string
-  assessmentName: string
-  folderName: string
-  candidateEmail: string
-  candidateName: string
-  deadline: string | null
-  timeLimit: number | null
-  startedAt: string
-}
-
-export interface SubmitResult {
-  success: boolean
-  submissionId: string
-  message: string
-}
-
-const TIMEOUT_MS = 30_000 // 30s for metadata/download requests
-
-/**
- * Fetch assessment metadata by token.
- * Marks the candidate as in_progress if they were pending.
- */
-export async function fetchInitMetadata(
-  apiBase: string,
-  token: string
-): Promise<InitMetadata> {
-  const url = `${apiBase}/api/cli/init?token=${encodeURIComponent(token)}`
-  const res = await fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS) })
-  const body = await res.json().catch(() => ({})) as Record<string, unknown>
-
-  if (!res.ok) {
-    const message = (body.message as string) || (body.error as string) || `Server returned ${res.status}`
-    throw new Error(message)
-  }
-
-  return body as unknown as InitMetadata
-}
-
-/**
- * Download the candidate ZIP by token.
- * Returns a ReadableStream of the ZIP bytes.
- */
-export async function downloadZip(
-  apiBase: string,
-  token: string
-): Promise<Response> {
-  const url = `${apiBase}/api/cli/download?token=${encodeURIComponent(token)}`
-  const res = await fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS) })
-
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({})) as Record<string, unknown>
-    const message = (body.message as string) || (body.error as string) || `Server returned ${res.status}`
-    throw new Error(message)
-  }
-
-  return res
-}
-
-/**
- * Upload a ZIP file for submission.
- * Streams the file to avoid loading it entirely into memory.
- * Calls onProgress with (bytesUploaded, totalBytes) during upload.
- */
-export async function submitZip(
-  apiBase: string,
-  token: string,
-  zipPath: string,
-  fileName: string,
-  onProgress?: (uploaded: number, total: number) => void
-): Promise<SubmitResult> {
-  const parsedUrl = new URL(`/api/cli/submit?token=${encodeURIComponent(token)}`, apiBase)
-  const fileSize = statSync(zipPath).size
-
-  const boundary = `----litmus${Date.now()}`
-  const headerBuf = Buffer.from(
-    `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${fileName}"\r\nContent-Type: application/zip\r\n\r\n`
-  )
-  const footerBuf = Buffer.from(`\r\n--${boundary}--\r\n`)
-  const totalSize = headerBuf.length + fileSize + footerBuf.length
-
-  return new Promise((resolve, reject) => {
-    const reqFn = parsedUrl.protocol === "https:" ? httpsRequest : httpRequest
-    const req = reqFn(parsedUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": `multipart/form-data; boundary=${boundary}`,
-        "Content-Length": totalSize.toString(),
-      },
-      timeout: 300_000, // 5 min for upload
-    }, (res) => {
-      let data = ""
-      res.on("data", (chunk: Buffer) => { data += chunk.toString() })
-      res.on("end", () => {
-        try {
-          const body = JSON.parse(data) as Record<string, unknown>
-          if (res.statusCode && res.statusCode >= 400) {
-            const message = (body.message as string) || (body.error as string) || `Server returned ${res.statusCode}`
-            reject(new Error(message))
-          } else {
-            resolve(body as unknown as SubmitResult)
-          }
-        } catch {
-          reject(new Error(`Server returned invalid response (${res.statusCode})`))
-        }
-      })
-    })
-
-    req.on("error", reject)
-    req.on("timeout", () => {
-      req.destroy(new Error("Upload timed out"))
-    })
-
-    // Write multipart header
-    req.write(headerBuf)
-    let uploaded = headerBuf.length
-
-    // Stream the file in chunks with backpressure handling
-    const fileStream = createReadStream(zipPath, { highWaterMark: 64 * 1024 })
-    fileStream.on("data", (chunk: string | Buffer) => {
-      uploaded += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length
-      onProgress?.(uploaded, totalSize)
-      if (!req.write(chunk)) {
-        fileStream.pause()
-        req.once("drain", () => fileStream.resume())
-      }
-    })
-    fileStream.on("end", () => {
-      req.end(footerBuf)
-    })
-    fileStream.on("error", (err) => {
-      req.destroy()
-      reject(err)
-    })
-  })
-}

package/src/lib/config.ts

@@ -1,79 +0,0 @@
-import { readFile, writeFile, mkdir } from "fs/promises"
-import { existsSync } from "fs"
-import path from "path"
-
-export interface LitmusConfig {
-  assessmentId: string
-  assessmentName: string
-  candidateEmail: string
-  candidateName: string
-  token: string
-  startedAt: string
-  deadline: string | null
-  timeLimit: number | null // minutes
-  apiBase: string
-}
-
-const CONFIG_DIR = ".litmus"
-const CONFIG_FILE = "config.json"
-
-export function getConfigPath(projectRoot: string): string {
-  return path.join(projectRoot, CONFIG_DIR, CONFIG_FILE)
-}
-
-export async function writeConfig(
-  projectRoot: string,
-  config: LitmusConfig
-): Promise<void> {
-  const configDir = path.join(projectRoot, CONFIG_DIR)
-  await mkdir(configDir, { recursive: true })
-  const configPath = path.join(configDir, CONFIG_FILE)
-  await writeFile(configPath, JSON.stringify(config, null, 2), "utf8")
-}
-
-/**
- * Walk up from cwd to find the directory containing .litmus/config.json.
- * Returns null if not found.
- */
-export function findProjectRoot(): string | null {
-  let dir = process.cwd()
-  while (true) {
-    const configPath = path.join(dir, CONFIG_DIR, CONFIG_FILE)
-    if (existsSync(configPath)) {
-      return dir
-    }
-    const parent = path.dirname(dir)
-    if (parent === dir) break
-    dir = parent
-  }
-  return null
-}
-
-/**
- * Read .litmus/config.json from the current directory or a parent directory.
- * Returns null if no config is found.
- */
-export async function readConfig(): Promise<LitmusConfig | null> {
-  let dir = process.cwd()
-
-  // Walk up the directory tree looking for .litmus/config.json
-  while (true) {
-    const configPath = path.join(dir, CONFIG_DIR, CONFIG_FILE)
-    if (existsSync(configPath)) {
-      const raw = await readFile(configPath, "utf8")
-      try {
-        return JSON.parse(raw) as LitmusConfig
-      } catch {
-        throw new Error(
-          `Your .litmus/config.json is corrupted. Delete the .litmus folder and re-run litmus init with your token.`
-        )
-      }
-    }
-
-    const parent = path.dirname(dir)
-    if (parent === dir) break // Reached filesystem root
-    dir = parent
-  }
-
-  return null
-}

package/src/lib/extract.ts

@@ -1,15 +0,0 @@
-import { mkdir } from "fs/promises"
-import unzipper from "unzipper"
-
-/**
- * Extract a ZIP file from disk to a target directory.
- * Using Open.file + extract() is the most reliable unzipper API.
- */
-export async function extractZip(
-  zipPath: string,
-  targetDir: string
-): Promise<void> {
-  await mkdir(targetDir, { recursive: true })
-  const directory = await unzipper.Open.file(zipPath)
-  await directory.extract({ path: targetDir })
-}

package/src/lib/tracker.ts

@@ -1,41 +0,0 @@
-import { spawn } from "child_process"
-import { mkdirSync, openSync, writeFileSync } from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-
-/**
- * Start the file watcher in the background.
- * Spawns dist/watcher.cjs as a detached process; logs file events to
- * <projectDir>/.litmus/activity.jsonl for later inclusion in the submission ZIP.
- */
-export function startTracker(projectDir: string): void {
-  const litmusDir = path.join(projectDir, ".litmus")
-  const activityLog = path.join(litmusDir, "activity.jsonl")
-  const pidFile = path.join(litmusDir, "tracker.pid")
-  const errLog = path.join(litmusDir, "tracker.log")
-  const watcherScript = path.join(__dirname, "watcher.cjs")
-
-  try {
-    mkdirSync(litmusDir, { recursive: true })
-  } catch {
-    // Non-critical
-  }
-
-  const errFd = openSync(errLog, "a")
-
-  const child = spawn("node", [watcherScript, projectDir, activityLog], {
-    detached: true,
-    stdio: ["ignore", "ignore", errFd],
-  })
-
-  if (child.pid) {
-    child.unref()
-    try {
-      writeFileSync(pidFile, String(child.pid), "utf8")
-    } catch {
-      // Non-critical
-    }
-  }
-}

package/src/lib/watcher.cjs

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-/**
- * Litmus file activity watcher.
- * Runs as a detached background process started by `litmus init`.
- * Usage: node watcher.cjs <projectDir> <activityLogPath>
- *
- * Uses Node's built-in fs.watch (no external dependencies).
- * Writes newline-delimited JSON to the activity log:
- *   { "ts": "ISO-8601", "type": "rename"|"change", "path": "relative/path" }
- */
-
-const fs = require("fs")
-const path = require("path")
-
-const [, , projectDir, activityLogPath] = process.argv
-
-process.stderr.write(`[watcher] starting: projectDir=${projectDir} log=${activityLogPath}\n`)
-process.stderr.write(`[watcher] node ${process.version}, platform=${process.platform}, arch=${process.arch}\n`)
-
-if (!projectDir || !activityLogPath) {
-  process.stderr.write("[watcher] missing arguments\n")
-  process.exit(1)
-}
-
-if (!fs.existsSync(projectDir)) {
-  process.stderr.write(`[watcher] projectDir does not exist: ${projectDir}\n`)
-  process.exit(1)
-}
-
-// Ensure the log directory exists
-fs.mkdirSync(path.dirname(activityLogPath), { recursive: true })
-
-// Open the log file for appending
-const log = fs.createWriteStream(activityLogPath, { flags: "a" })
-
-const IGNORED = [
-  /[/\\]\./,          // dotfiles and dotdirs (including .git, .litmus)
-  /node_modules/,
-  /__pycache__/,
-  /\.pyc$/,
-  /\.class$/,
-  /[/\\]venv[/\\]/,
-  /[/\\]\.venv[/\\]/,
-]
-
-function shouldIgnore(relPath) {
-  return IGNORED.some((re) => re.test(relPath))
-}
-
-function write(type, relPath) {
-  const event = JSON.stringify({
-    ts: new Date().toISOString(),
-    type,
-    path: relPath,
-  })
-  log.write(event + "\n")
-}
-
-process.on("uncaughtException", (err) => {
-  process.stderr.write(`[watcher] uncaughtException: ${err.stack || err}\n`)
-  process.exit(1)
-})
-
-try {
-  const watcher = fs.watch(projectDir, { recursive: true }, (eventType, filename) => {
-    if (!filename) return
-    if (shouldIgnore(filename)) return
-    write(eventType, filename)
-  })
-
-  watcher.on("error", (err) => {
-    process.stderr.write(`[watcher] fs.watch error: ${err}\n`)
-  })
-
-  process.stderr.write("[watcher] started successfully\n")
-} catch (err) {
-  process.stderr.write(`[watcher] failed to start: ${err.stack || err}\n`)
-  process.exit(1)
-}

package/src/lib/zip.ts

@@ -1,110 +0,0 @@
-import { readFileSync, existsSync } from "fs"
-import path from "path"
-import os from "os"
-import fg from "fast-glob"
-import { Zip } from "zip-lib"
-
-// Directories always excluded from submissions.
-// NOTE: .git is intentionally NOT excluded — git history is included so the
-// analysis backend can run parse_git_history() on the submission.
-const ALWAYS_EXCLUDE = [
-  "node_modules",
-  "__pycache__",
-  "venv",
-  ".venv",
-  "env",
-  ".env",
-  "target",        // Rust/Java build output
-  "build",
-  "dist",
-  ".gradle",
-  ".idea",
-  ".DS_Store",
-  "*.pyc",
-  "*.class",
-  // Legacy injected tracking files — exclude so they don't pollute submissions
-  // from assessments downloaded before the CLI-native tracking was deployed.
-  "setup.sh",
-  "tracker.py",
-  "tracker.js",
-  "heartbeat.py",
-]
-
-/**
- * Create a ZIP of the project directory for submission.
- * Respects .gitignore patterns (basic support) and excludes common large dirs.
- * Always includes .litmus/activity.jsonl (the tracking log).
- *
- * @param projectDir - Root of the project to zip
- * @returns Path to the temporary ZIP file
- */
-export async function createSubmissionZip(projectDir: string): Promise<string> {
-  const tmpFile = path.join(os.tmpdir(), `litmus-submission-${Date.now()}.zip`)
-
-  // Compute glob patterns to ignore
-  const ignoredGlobs = buildIgnoreGlobs(projectDir)
-
-  // Find all files, including dotfiles
-  const files = await fg(["**/*"], {
-    cwd: projectDir,
-    dot: true,
-    onlyFiles: true,
-    followSymbolicLinks: false,
-    ignore: ignoredGlobs,
-  })
-
-  // Always include activity log if it exists
-  const activityPath = ".litmus/activity.jsonl"
-  if (existsSync(path.join(projectDir, activityPath)) && !files.includes(activityPath)) {
-    files.push(activityPath)
-  }
-
-  const zip = new Zip({ compressionLevel: 6 })
-  for (const file of files) {
-    zip.addFile(path.join(projectDir, file), file)
-  }
-  await zip.archive(tmpFile)
-
-  return tmpFile
-}
-
-function buildIgnoreGlobs(projectDir: string): string[] {
-  const patterns: string[] = []
-
-  // Always-excluded dirs/patterns
-  for (const excluded of ALWAYS_EXCLUDE) {
-    if (excluded.startsWith("*")) {
-      patterns.push(excluded)
-    } else {
-      patterns.push(`${excluded}/**`)
-      patterns.push(`**/${excluded}/**`)
-    }
-  }
-
-  // Basic .gitignore support
-  const gitignorePath = path.join(projectDir, ".gitignore")
-  if (existsSync(gitignorePath)) {
-    try {
-      const lines = readFileSync(gitignorePath, "utf8")
-        .split("\n")
-        .map((l) => l.trim())
-        .filter((l) => l && !l.startsWith("#"))
-
-      for (const line of lines) {
-        if (line.endsWith("/")) {
-          // Directory pattern
-          const dir = line.slice(0, -1)
-          patterns.push(`${dir}/**`)
-          patterns.push(`**/${dir}/**`)
-        } else {
-          patterns.push(line)
-          patterns.push(`**/${line}`)
-        }
-      }
-    } catch {
-      // Ignore .gitignore parse errors
-    }
-  }
-
-  return patterns
-}

package/src/utils/detect-project.ts

@@ -1,84 +0,0 @@
-import { existsSync, readdirSync } from "fs"
-import path from "path"
-
-export type ProjectType =
-  | "node"
-  | "python"
-  | "go"
-  | "java"
-  | "dotnet"
-  | "rust"
-  | "ruby"
-  | "php"
-  | "unknown"
-
-export interface ProjectInfo {
-  type: ProjectType
-  installCommand: string | null
-  runHint: string | null
-}
-
-/**
- * Detect project type and suggest an install command.
- */
-export function detectProject(dir: string): ProjectInfo {
-  if (existsSync(path.join(dir, "package.json"))) {
-    const hasYarnLock = existsSync(path.join(dir, "yarn.lock"))
-    const hasPnpmLock = existsSync(path.join(dir, "pnpm-lock.yaml"))
-    const installCommand = hasPnpmLock
-      ? "pnpm install"
-      : hasYarnLock
-        ? "yarn"
-        : "npm install"
-    return { type: "node", installCommand, runHint: "npm start / npm test" }
-  }
-
-  if (
-    existsSync(path.join(dir, "requirements.txt")) ||
-    existsSync(path.join(dir, "pyproject.toml")) ||
-    existsSync(path.join(dir, "setup.py"))
-  ) {
-    // Create a venv and install into it (replaces what the old setup.sh did).
-    // Use venv/bin/pip directly so activation isn't required at install time.
-    const pipBin = process.platform === "win32" ? "venv\\Scripts\\pip" : "venv/bin/pip"
-    const installCommand = existsSync(path.join(dir, "requirements.txt"))
-      ? `python3 -m venv venv && ${pipBin} install -r requirements.txt`
-      : `python3 -m venv venv && ${pipBin} install -e .`
-    return {
-      type: "python",
-      installCommand,
-      runHint: "source venv/bin/activate  # then: python main.py / pytest",
-    }
-  }
-
-  if (existsSync(path.join(dir, "go.mod"))) {
-    return { type: "go", installCommand: "go mod download", runHint: "go run . / go test ./..." }
-  }
-
-  if (existsSync(path.join(dir, "pom.xml"))) {
-    return { type: "java", installCommand: "mvn install", runHint: "mvn test" }
-  }
-
-  if (existsSync(path.join(dir, "build.gradle")) || existsSync(path.join(dir, "build.gradle.kts"))) {
-    return { type: "java", installCommand: "gradle build", runHint: "gradle test" }
-  }
-
-  const files = readdirSync(dir)
-  if (files.some(f => f.endsWith(".csproj") || f.endsWith(".sln"))) {
-    return { type: "dotnet", installCommand: "dotnet restore", runHint: "dotnet run / dotnet test" }
-  }
-
-  if (existsSync(path.join(dir, "Cargo.toml"))) {
-    return { type: "rust", installCommand: null, runHint: "cargo run / cargo test" }
-  }
-
-  if (existsSync(path.join(dir, "Gemfile"))) {
-    return { type: "ruby", installCommand: "bundle install", runHint: "ruby main.rb / rspec" }
-  }
-
-  if (existsSync(path.join(dir, "composer.json"))) {
-    return { type: "php", installCommand: "composer install", runHint: "php -S localhost:8000" }
-  }
-
-  return { type: "unknown", installCommand: null, runHint: null }
-}

package/src/utils/errors.ts

@@ -1,41 +0,0 @@
-import chalk from "chalk"
-
-export const FALLBACK_URL = "https://www.litmus.build"
-
-/**
- * Print a plain-English error and exit.
- * Always shows a fallback URL for candidates who can't resolve the issue.
- */
-export function fatal(message: string, hint?: string): never {
-  console.error()
-  console.error(chalk.red("✗ Error: ") + message)
-  if (hint) {
-    console.error(chalk.dim("  Hint: ") + hint)
-  }
-  console.error(
-    chalk.dim(`  Need help? Visit ${FALLBACK_URL} or contact the company directly.`)
-  )
-  console.error()
-  process.exit(1)
-}
-
-/**
- * Print a warning (non-fatal).
- */
-export function warn(message: string): void {
-  console.warn(chalk.yellow("⚠ Warning: ") + message)
-}
-
-/**
- * Print a success message.
- */
-export function success(message: string): void {
-  console.log(chalk.green("✓ ") + message)
-}
-
-/**
- * Print a plain info line.
- */
-export function info(message: string): void {
-  console.log(chalk.dim("  ") + message)
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2020"],
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}