@vibe-interviewing/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vibe-interviewing contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,472 @@
+import { z } from 'zod';
+
+declare const AIRulesSchema: z.ZodObject<{
+    /** Role description for the AI assistant */
+    role: z.ZodString;
+    /** Behavioral rules (e.g., "don't reveal the answer") */
+    rules: z.ZodArray<z.ZodString, "many">;
+    /** Knowledge about the bug/solution (hidden from candidate) */
+    knowledge: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    rules: string[];
+    knowledge: string;
+}, {
+    role: string;
+    rules: string[];
+    knowledge: string;
+}>;
+declare const EvaluationSchema: z.ZodObject<{
+    /** Evaluation criteria for the interviewer */
+    criteria: z.ZodArray<z.ZodString, "many">;
+    /** Description of the expected fix */
+    expected_fix: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    criteria: string[];
+    expected_fix?: string | undefined;
+}, {
+    criteria: string[];
+    expected_fix?: string | undefined;
+}>;
+/** Full scenario configuration schema */
+declare const ScenarioConfigSchema: z.ZodObject<{
+    /** Scenario display name */
+    name: z.ZodString;
+    /** One-line description */
+    description: z.ZodString;
+    /** Difficulty level */
+    difficulty: z.ZodEnum<["easy", "medium", "hard"]>;
+    /** Estimated time (e.g., "30-45m") */
+    estimated_time: z.ZodString;
+    /** Searchable tags */
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** GitHub repo URL or owner/repo shorthand */
+    repo: z.ZodString;
+    /** Commit SHA to pin the clone to (ensures reproducibility) */
+    commit: z.ZodString;
+    /** Shell commands to run after cloning (e.g., ["npm install"]) */
+    setup: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Find-and-replace patches to inject the bug after cloning */
+    patch: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Path to the file relative to repo root */
+        file: z.ZodString;
+        /** The original text to find */
+        find: z.ZodString;
+        /** The replacement text (with the bug) */
+        replace: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        find: string;
+        file: string;
+        replace: string;
+    }, {
+        find: string;
+        file: string;
+        replace: string;
+    }>, "many">>;
+    /** Briefing shown to the candidate (written like a team lead message) */
+    briefing: z.ZodString;
+    /** AI behavioral rules (injected via system prompt, hidden from candidate) */
+    ai_rules: z.ZodObject<{
+        /** Role description for the AI assistant */
+        role: z.ZodString;
+        /** Behavioral rules (e.g., "don't reveal the answer") */
+        rules: z.ZodArray<z.ZodString, "many">;
+        /** Knowledge about the bug/solution (hidden from candidate) */
+        knowledge: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        rules: string[];
+        knowledge: string;
+    }, {
+        role: string;
+        rules: string[];
+        knowledge: string;
+    }>;
+    /** Interviewer reference — what the fix looks like */
+    solution: z.ZodString;
+    /** Evaluation rubric */
+    evaluation: z.ZodOptional<z.ZodObject<{
+        /** Evaluation criteria for the interviewer */
+        criteria: z.ZodArray<z.ZodString, "many">;
+        /** Description of the expected fix */
+        expected_fix: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        criteria: string[];
+        expected_fix?: string | undefined;
+    }, {
+        criteria: string[];
+        expected_fix?: string | undefined;
+    }>>;
+    /** License of the original project */
+    license: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    difficulty: "easy" | "medium" | "hard";
+    estimated_time: string;
+    tags: string[];
+    repo: string;
+    commit: string;
+    setup: string[];
+    patch: {
+        find: string;
+        file: string;
+        replace: string;
+    }[];
+    briefing: string;
+    ai_rules: {
+        role: string;
+        rules: string[];
+        knowledge: string;
+    };
+    solution: string;
+    evaluation?: {
+        criteria: string[];
+        expected_fix?: string | undefined;
+    } | undefined;
+    license?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    difficulty: "easy" | "medium" | "hard";
+    estimated_time: string;
+    repo: string;
+    commit: string;
+    briefing: string;
+    ai_rules: {
+        role: string;
+        rules: string[];
+        knowledge: string;
+    };
+    solution: string;
+    tags?: string[] | undefined;
+    setup?: string[] | undefined;
+    patch?: {
+        find: string;
+        file: string;
+        replace: string;
+    }[] | undefined;
+    evaluation?: {
+        criteria: string[];
+        expected_fix?: string | undefined;
+    } | undefined;
+    license?: string | undefined;
+}>;
+type ScenarioConfig = z.infer<typeof ScenarioConfigSchema>;
+type AIRules = z.infer<typeof AIRulesSchema>;
+type Evaluation = z.infer<typeof EvaluationSchema>;
+/** Metadata about a discovered scenario */
+interface ScenarioInfo {
+    /** Scenario name */
+    name: string;
+    /** Parsed config */
+    config: ScenarioConfig;
+    /** Whether this is a built-in scenario */
+    builtIn: boolean;
+}
+
+/**
+ * Load and parse a scenario config from a YAML file.
+ *
+ * @param configPath - Absolute path to the scenario.yaml file
+ * @returns The parsed and validated scenario config
+ */
+declare function loadScenarioConfig(configPath: string): Promise<ScenarioConfig>;
+/**
+ * Generate a system prompt string from a scenario's ai_rules.
+ *
+ * This prompt is injected into the AI tool via --append-system-prompt
+ * and is hidden from the candidate.
+ *
+ * @param config - The scenario config containing ai_rules
+ * @returns The formatted system prompt
+ */
+declare function generateSystemPrompt(config: ScenarioConfig): string;
+
+/** Result of validating a scenario configuration */
+interface ValidationResult {
+    /** Whether the scenario is valid (no errors) */
+    valid: boolean;
+    /** Non-fatal issues that should be addressed */
+    warnings: string[];
+    /** Fatal issues that prevent the scenario from running */
+    errors: string[];
+}
+/**
+ * Validate a scenario config for completeness and correctness.
+ *
+ * @param config - The scenario config to validate
+ * @returns Validation result with errors and warnings
+ */
+declare function validateScenario(config: ScenarioConfig): Promise<ValidationResult>;
+/**
+ * Validate a scenario config and throw if invalid.
+ *
+ * @param config - The scenario config to validate
+ * @returns Validation result (only returned if valid)
+ * @throws ScenarioValidationError if the config has errors
+ */
+declare function validateScenarioOrThrow(config: ScenarioConfig): Promise<ValidationResult>;
+
+/**
+ * Discover built-in scenarios from the registry.yaml file in the scenarios package.
+ *
+ * Each entry in the registry points to a scenario directory containing a full
+ * scenario.yaml. The registry provides quick lookup metadata, while the full
+ * config is loaded from the scenario's own config file.
+ *
+ * @returns Array of discovered scenario info objects
+ */
+declare function discoverBuiltInScenarios(): Promise<ScenarioInfo[]>;
+/**
+ * Discover all available scenarios.
+ *
+ * Currently returns only built-in scenarios from the registry.
+ * Local scenario support can be added later.
+ *
+ * @returns Array of all discovered scenario info objects
+ */
+declare function discoverAllScenarios(): Promise<ScenarioInfo[]>;
+
+/**
+ * Import a repository by cloning it to a local directory.
+ *
+ * For commit SHAs, uses a shallow fetch to avoid downloading full history.
+ *
+ * @param repoUrl - GitHub URL, SSH URL, or owner/repo shorthand
+ * @param targetPath - Directory to clone into (defaults to a temp directory)
+ * @param ref - Optional branch, tag, or commit to checkout
+ * @returns The path to the cloned directory
+ */
+declare function importRepo(repoUrl: string, targetPath?: string, ref?: string): Promise<string>;
+
+/** Event types that can be captured during a session */
+type SessionEventType = 'stdout' | 'stderr' | 'command' | 'note';
+/** A single timestamped event captured during a session */
+interface SessionEvent {
+    /** Milliseconds since recording started */
+    timestamp: number;
+    /** The kind of event */
+    type: SessionEventType;
+    /** The captured data */
+    data: string;
+}
+/** Serialized recording format */
+interface RecordingData {
+    /** Session ID this recording belongs to */
+    sessionId: string;
+    /** ISO string of when recording started */
+    startedAt: string;
+    /** All captured events */
+    events: SessionEvent[];
+}
+/**
+ * Records timestamped events during an interview session.
+ *
+ * Captures stdout, stderr, commands, and notes with millisecond timestamps
+ * relative to when the recorder was created.
+ */
+declare class SessionRecorder {
+    private readonly events;
+    private readonly startTime;
+    private readonly startedAt;
+    constructor();
+    /** Record a timestamped event */
+    record(type: SessionEventType, data: string): void;
+    /** Get all recorded events */
+    getEvents(): ReadonlyArray<SessionEvent>;
+    /** Serialize the recording to a JSON-compatible object */
+    toJSON(sessionId: string): RecordingData;
+    /** Create a SessionRecorder pre-populated with events from serialized data */
+    static fromJSON(data: RecordingData): SessionRecorder;
+    /** Save the recording to disk */
+    save(sessionId: string): Promise<void>;
+    /** Load a recording from disk */
+    static load(sessionId: string): Promise<SessionRecorder>;
+    /** List all available recording session IDs */
+    static list(): Promise<string[]>;
+}
+
+/** Configuration for launching an AI coding tool */
+interface LaunchConfig {
+    /** Scenario name for display */
+    scenarioName: string;
+    /** Path to system prompt file (hidden from candidate) */
+    systemPromptPath: string;
+    /** Model to use */
+    model?: string;
+    /** Permission mode for the AI tool */
+    permissionMode?: 'default' | 'plan' | 'acceptEdits' | 'bypassPermissions';
+    /** Tools to disallow (e.g., WebSearch for fairness) */
+    disallowedTools?: string[];
+    /** Whether to record stdout/stderr during the session */
+    recording?: boolean;
+}
+/** A running AI tool process */
+interface LaunchedProcess {
+    /** Wait for the process to exit */
+    wait(): Promise<{
+        exitCode: number;
+    }>;
+    /** Kill the process */
+    kill(): Promise<void>;
+    /** Session recorder, present when recording is enabled */
+    recorder?: SessionRecorder;
+}
+/** Interface for AI coding tool launchers */
+interface AIToolLauncher {
+    /** Internal name identifier */
+    readonly name: string;
+    /** Human-readable display name */
+    readonly displayName: string;
+    /** Check if this tool is installed and accessible */
+    isInstalled(): Promise<boolean>;
+    /** Get the installed version string */
+    getVersion(): Promise<string | null>;
+    /** Launch the tool pointed at a working directory */
+    launch(workdir: string, config: LaunchConfig): Promise<LaunchedProcess>;
+}
+
+/** Launcher for Anthropic's Claude Code CLI */
+declare class ClaudeCodeLauncher implements AIToolLauncher {
+    readonly name = "claude-code";
+    readonly displayName = "Claude Code";
+    /** Check if the claude CLI is installed */
+    isInstalled(): Promise<boolean>;
+    /** Get the installed Claude Code version */
+    getVersion(): Promise<string | null>;
+    /** Launch Claude Code in the given working directory with the provided config */
+    launch(workdir: string, config: LaunchConfig): Promise<LaunchedProcess>;
+}
+
+/** Information about a detected AI coding tool */
+interface DetectedTool {
+    /** The launcher instance */
+    launcher: AIToolLauncher;
+    /** Installed version string, or null if unknown */
+    version: string | null;
+}
+/** Detect which AI coding tools are installed on the system */
+declare function detectInstalledTools(): Promise<DetectedTool[]>;
+/** Get a launcher by its internal name */
+declare function getLauncher(name: string): AIToolLauncher | undefined;
+/** Get all registered launchers */
+declare function getAllLaunchers(): AIToolLauncher[];
+
+/** Status of an interview session */
+type SessionStatus = 'cloning' | 'setting-up' | 'running' | 'complete';
+/** A live interview session */
+interface Session {
+    /** Unique session identifier */
+    id: string;
+    /** Name of the scenario being run */
+    scenarioName: string;
+    /** Local working directory for the candidate */
+    workdir: string;
+    /** Path to the system prompt file (outside workspace) */
+    systemPromptPath: string;
+    /** Current session status */
+    status: SessionStatus;
+    /** ISO timestamp of session creation */
+    createdAt: string;
+    /** ISO timestamp of when the AI tool was launched */
+    startedAt?: string;
+    /** ISO timestamp of session completion */
+    completedAt?: string;
+    /** Name of the AI tool used */
+    aiTool?: string;
+}
+/** Serializable session data for persistence */
+interface StoredSession {
+    /** Unique session identifier */
+    id: string;
+    /** Name of the scenario being run */
+    scenarioName: string;
+    /** Current session status */
+    status: SessionStatus;
+    /** Local working directory for the candidate */
+    workdir: string;
+    /** Path to the system prompt file */
+    systemPromptPath: string;
+    /** Name of the AI tool used */
+    aiTool?: string;
+    /** ISO timestamp of session creation */
+    createdAt: string;
+    /** ISO timestamp of when the AI tool was launched */
+    startedAt?: string;
+    /** ISO timestamp of session completion */
+    completedAt?: string;
+}
+/** Convert a Session to a StoredSession for persistence */
+declare function toStoredSession(session: Session): StoredSession;
+
+/** Callback for reporting session progress */
+type ProgressCallback = (stage: string) => void;
+/** Manages the lifecycle of an interview session */
+declare class SessionManager {
+    private launcher;
+    constructor(launcher: AIToolLauncher);
+    /**
+     * Create a new interview session.
+     *
+     * Flow:
+     * 1. Clone the repo at a pinned commit
+     * 2. Apply bug patches (find/replace in source files)
+     * 3. Wipe git history so the candidate can't diff to find the bug
+     * 4. Remove scenario.yaml from workspace (interviewer-only)
+     * 5. Write BRIEFING.md and system prompt
+     * 6. Run setup commands (npm install, etc.)
+     */
+    createSession(config: ScenarioConfig, workdir?: string, onProgress?: ProgressCallback): Promise<{
+        session: Session;
+        config: ScenarioConfig;
+    }>;
+    /** Launch the AI coding tool for an active session */
+    launchAITool(session: Session, _config: ScenarioConfig, launchConfig?: Partial<LaunchConfig>): Promise<{
+        exitCode: number;
+    }>;
+    /** Destroy a session by removing its stored data */
+    destroySession(session: Session): Promise<void>;
+    /** Get elapsed time since the AI tool was launched, formatted as a human-readable string */
+    getElapsedTime(session: Session): string | null;
+}
+
+/** Save a session to disk */
+declare function saveSession(session: StoredSession): Promise<void>;
+/** Load a session from disk */
+declare function loadSession(id: string): Promise<StoredSession | null>;
+/** Delete a session from disk */
+declare function deleteSession(id: string): Promise<void>;
+/** List all stored sessions */
+declare function listSessions(): Promise<StoredSession[]>;
+/** List only active (non-complete) sessions */
+declare function listActiveSessions(): Promise<StoredSession[]>;
+
+/** Base error class for all vibe-interviewing errors */
+declare class VibeError extends Error {
+    readonly code: string;
+    readonly hint?: string | undefined;
+    constructor(message: string, code: string, hint?: string | undefined);
+}
+declare class ScenarioNotFoundError extends VibeError {
+    constructor(name: string);
+}
+declare class ScenarioValidationError extends VibeError {
+    readonly issues: string[];
+    constructor(message: string, issues: string[]);
+}
+declare class AIToolNotFoundError extends VibeError {
+    static readonly installHints: Record<string, string>;
+    constructor(tool: string);
+}
+declare class SessionNotFoundError extends VibeError {
+    constructor(id: string);
+}
+declare class GitCloneError extends VibeError {
+    constructor(repo: string, reason?: string);
+}
+declare class SetupError extends VibeError {
+    constructor(command: string, reason?: string);
+}
+
+export { type AIRules, type AIToolLauncher, AIToolNotFoundError, ClaudeCodeLauncher, type DetectedTool, type Evaluation, GitCloneError, type LaunchConfig, type LaunchedProcess, type ProgressCallback, type RecordingData, type ScenarioConfig, ScenarioConfigSchema, type ScenarioInfo, ScenarioNotFoundError, ScenarioValidationError, type Session, type SessionEvent, type SessionEventType, SessionManager, SessionNotFoundError, SessionRecorder, SetupError, type StoredSession, type ValidationResult, VibeError, deleteSession, detectInstalledTools, discoverAllScenarios, discoverBuiltInScenarios, generateSystemPrompt, getAllLaunchers, getLauncher, importRepo, listActiveSessions, listSessions, loadScenarioConfig, loadSession, saveSession, toStoredSession, validateScenario, validateScenarioOrThrow };

package/dist/index.js

@@ -0,0 +1,642 @@
+// src/scenario/types.ts
+import { z } from "zod";
+var AIRulesSchema = z.object({
+  /** Role description for the AI assistant */
+  role: z.string(),
+  /** Behavioral rules (e.g., "don't reveal the answer") */
+  rules: z.array(z.string()),
+  /** Knowledge about the bug/solution (hidden from candidate) */
+  knowledge: z.string()
+});
+var EvaluationSchema = z.object({
+  /** Evaluation criteria for the interviewer */
+  criteria: z.array(z.string()),
+  /** Description of the expected fix */
+  expected_fix: z.string().optional()
+});
+var PatchSchema = z.object({
+  /** Path to the file relative to repo root */
+  file: z.string(),
+  /** The original text to find */
+  find: z.string(),
+  /** The replacement text (with the bug) */
+  replace: z.string()
+});
+var ScenarioConfigSchema = z.object({
+  /** Scenario display name */
+  name: z.string(),
+  /** One-line description */
+  description: z.string(),
+  /** Difficulty level */
+  difficulty: z.enum(["easy", "medium", "hard"]),
+  /** Estimated time (e.g., "30-45m") */
+  estimated_time: z.string(),
+  /** Searchable tags */
+  tags: z.array(z.string()).default([]),
+  /** GitHub repo URL or owner/repo shorthand */
+  repo: z.string(),
+  /** Commit SHA to pin the clone to (ensures reproducibility) */
+  commit: z.string(),
+  /** Shell commands to run after cloning (e.g., ["npm install"]) */
+  setup: z.array(z.string()).default([]),
+  /** Find-and-replace patches to inject the bug after cloning */
+  patch: z.array(PatchSchema).default([]),
+  /** Briefing shown to the candidate (written like a team lead message) */
+  briefing: z.string(),
+  /** AI behavioral rules (injected via system prompt, hidden from candidate) */
+  ai_rules: AIRulesSchema,
+  /** Interviewer reference — what the fix looks like */
+  solution: z.string(),
+  /** Evaluation rubric */
+  evaluation: EvaluationSchema.optional(),
+  /** License of the original project */
+  license: z.string().optional()
+});
+
+// src/scenario/loader.ts
+import { readFile } from "fs/promises";
+import { parse as parseYaml } from "yaml";
+
+// src/errors.ts
+var VibeError = class extends Error {
+  constructor(message, code, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.name = "VibeError";
+  }
+};
+var ScenarioNotFoundError = class extends VibeError {
+  constructor(name) {
+    super(
+      `Scenario not found: ${name}`,
+      "SCENARIO_NOT_FOUND",
+      "Run `vibe-interviewing list` to see available scenarios"
+    );
+  }
+};
+var ScenarioValidationError = class extends VibeError {
+  constructor(message, issues) {
+    super(`Invalid scenario config: ${message}`, "SCENARIO_VALIDATION_ERROR", issues.join("\n"));
+    this.issues = issues;
+  }
+};
+var AIToolNotFoundError = class _AIToolNotFoundError extends VibeError {
+  static installHints = {
+    "claude-code": "Install Claude Code: npm install -g @anthropic-ai/claude-code"
+  };
+  constructor(tool) {
+    super(
+      `${tool} is not installed`,
+      "AI_TOOL_NOT_FOUND",
+      _AIToolNotFoundError.installHints[tool] ?? `Install ${tool} and try again`
+    );
+  }
+};
+var SessionNotFoundError = class extends VibeError {
+  constructor(id) {
+    super(
+      `Session not found: ${id}`,
+      "SESSION_NOT_FOUND",
+      "Run `vibe-interviewing list` to see active sessions"
+    );
+  }
+};
+var GitCloneError = class extends VibeError {
+  constructor(repo, reason) {
+    super(
+      `Failed to clone repository: ${repo}${reason ? ` \u2014 ${reason}` : ""}`,
+      "GIT_CLONE_FAILED",
+      "Check the repo URL and your network connection"
+    );
+  }
+};
+var SetupError = class extends VibeError {
+  constructor(command, reason) {
+    super(
+      `Setup command failed: ${command}${reason ? ` \u2014 ${reason}` : ""}`,
+      "SETUP_FAILED",
+      "Check the scenario setup commands and try again"
+    );
+  }
+};
+
+// src/scenario/loader.ts
+import { existsSync } from "fs";
+async function loadScenarioConfig(configPath) {
+  if (!existsSync(configPath)) {
+    throw new ScenarioNotFoundError(configPath);
+  }
+  const raw = await readFile(configPath, "utf-8");
+  const parsed = parseYaml(raw);
+  const result = ScenarioConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`);
+    throw new ScenarioValidationError("validation failed", issues);
+  }
+  return result.data;
+}
+function generateSystemPrompt(config) {
+  const lines = [];
+  lines.push(`# Interview Scenario: ${config.name}`);
+  lines.push("");
+  lines.push("## Your Role");
+  lines.push(config.ai_rules.role.trim());
+  lines.push("");
+  lines.push("## Rules");
+  for (const rule of config.ai_rules.rules) {
+    lines.push(`- ${rule}`);
+  }
+  lines.push("");
+  lines.push("## Knowledge (DO NOT share directly with the candidate)");
+  lines.push(config.ai_rules.knowledge.trim());
+  return lines.join("\n");
+}
+
+// src/scenario/validator.ts
+async function validateScenario(config) {
+  const warnings = [];
+  const errors = [];
+  if (!config.briefing.trim()) {
+    errors.push("Briefing cannot be empty");
+  }
+  if (!config.ai_rules.role.trim()) {
+    errors.push("ai_rules.role cannot be empty");
+  }
+  if (!config.repo.trim()) {
+    errors.push("repo cannot be empty");
+  }
+  if (!config.commit.trim()) {
+    errors.push("commit cannot be empty \u2014 pin to a specific commit SHA for reproducibility");
+  }
+  if (config.ai_rules.rules.length === 0) {
+    warnings.push("ai_rules.rules is empty \u2014 the AI will have no behavioral constraints");
+  }
+  if (!config.solution.trim()) {
+    warnings.push("solution is empty \u2014 interviewers will have no solution reference");
+  }
+  if (!config.evaluation) {
+    warnings.push("No evaluation criteria defined");
+  }
+  return {
+    valid: errors.length === 0,
+    warnings,
+    errors
+  };
+}
+async function validateScenarioOrThrow(config) {
+  const result = await validateScenario(config);
+  if (!result.valid) {
+    throw new ScenarioValidationError("scenario validation failed", result.errors);
+  }
+  return result;
+}
+
+// src/scenario/registry.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { parse as parseYaml2 } from "yaml";
+async function getScenariosPackagePath() {
+  try {
+    const { getScenariosDir } = await import("@vibe-interviewing/scenarios");
+    return getScenariosDir();
+  } catch {
+    const fromCwd = join(process.cwd(), "packages", "scenarios");
+    if (existsSync2(fromCwd)) {
+      return fromCwd;
+    }
+    throw new Error("Could not locate @vibe-interviewing/scenarios package");
+  }
+}
+async function discoverBuiltInScenarios() {
+  const scenariosPath = await getScenariosPackagePath();
+  const registryPath = join(scenariosPath, "registry.yaml");
+  if (!existsSync2(registryPath)) {
+    return [];
+  }
+  const raw = await readFile2(registryPath, "utf-8");
+  const registry = parseYaml2(raw);
+  if (!registry.scenarios || !Array.isArray(registry.scenarios)) {
+    return [];
+  }
+  const scenarios = [];
+  for (const entry of registry.scenarios) {
+    const scenarioConfigPath = join(scenariosPath, entry.name, "scenario.yaml");
+    if (existsSync2(scenarioConfigPath)) {
+      const config = await loadScenarioConfig(scenarioConfigPath);
+      scenarios.push({
+        name: entry.name,
+        config,
+        builtIn: true
+      });
+    }
+  }
+  return scenarios;
+}
+async function discoverAllScenarios() {
+  return discoverBuiltInScenarios();
+}
+
+// src/scenario/importer.ts
+import { mkdtemp } from "fs/promises";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+async function importRepo(repoUrl, targetPath, ref) {
+  const { simpleGit } = await import("simple-git");
+  const url = normalizeRepoUrl(repoUrl);
+  const dest = targetPath ?? await mkdtemp(join2(tmpdir(), "vibe-import-"));
+  const git = simpleGit();
+  try {
+    if (ref && /^[0-9a-f]{7,40}$/i.test(ref)) {
+      await git.init([dest]);
+      const repoGit = simpleGit(dest);
+      await repoGit.addRemote("origin", url);
+      await repoGit.fetch(["origin", ref, "--depth", "1"]);
+      await repoGit.checkout(["FETCH_HEAD"]);
+    } else if (ref) {
+      await git.clone(url, dest, ["--depth", "1", "--branch", ref]);
+    } else {
+      await git.clone(url, dest, ["--depth", "1"]);
+    }
+  } catch (err) {
+    throw new GitCloneError(url, err instanceof Error ? err.message : String(err));
+  }
+  return dest;
+}
+function normalizeRepoUrl(input) {
+  if (input.startsWith("http://") || input.startsWith("https://")) {
+    return input;
+  }
+  if (input.startsWith("git@")) {
+    return input.replace("git@github.com:", "https://github.com/").replace(/\.git$/, "");
+  }
+  if (/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9._-]+$/.test(input)) {
+    return `https://github.com/${input}`;
+  }
+  return input;
+}
+
+// src/launcher/claude-code.ts
+import { spawn } from "child_process";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { readFile as readFile4 } from "fs/promises";
+
+// src/session/recorder.ts
+import { readFile as readFile3, writeFile, readdir, mkdir } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir } from "os";
+import { existsSync as existsSync3 } from "fs";
+var RECORDINGS_DIR = join3(homedir(), ".vibe-interviewing", "recordings");
+async function ensureRecordingsDir() {
+  if (!existsSync3(RECORDINGS_DIR)) {
+    await mkdir(RECORDINGS_DIR, { recursive: true });
+  }
+}
+var SessionRecorder = class _SessionRecorder {
+  events = [];
+  startTime;
+  startedAt;
+  constructor() {
+    this.startTime = Date.now();
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  /** Record a timestamped event */
+  record(type, data) {
+    this.events.push({
+      timestamp: Date.now() - this.startTime,
+      type,
+      data
+    });
+  }
+  /** Get all recorded events */
+  getEvents() {
+    return this.events;
+  }
+  /** Serialize the recording to a JSON-compatible object */
+  toJSON(sessionId) {
+    return {
+      sessionId,
+      startedAt: this.startedAt,
+      events: [...this.events]
+    };
+  }
+  /** Create a SessionRecorder pre-populated with events from serialized data */
+  static fromJSON(data) {
+    const recorder = new _SessionRecorder();
+    Object.defineProperty(recorder, "startedAt", { value: data.startedAt });
+    for (const event of data.events) {
+      recorder.events.push({ ...event });
+    }
+    return recorder;
+  }
+  /** Save the recording to disk */
+  async save(sessionId) {
+    await ensureRecordingsDir();
+    const filePath = join3(RECORDINGS_DIR, `${sessionId}.json`);
+    const data = this.toJSON(sessionId);
+    await writeFile(filePath, JSON.stringify(data, null, 2));
+  }
+  /** Load a recording from disk */
+  static async load(sessionId) {
+    const filePath = join3(RECORDINGS_DIR, `${sessionId}.json`);
+    const raw = await readFile3(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    return _SessionRecorder.fromJSON(data);
+  }
+  /** List all available recording session IDs */
+  static async list() {
+    await ensureRecordingsDir();
+    const files = await readdir(RECORDINGS_DIR);
+    return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, "")).sort();
+  }
+};
+
+// src/launcher/claude-code.ts
+var execFileAsync = promisify(execFile);
+var ClaudeCodeLauncher = class {
+  name = "claude-code";
+  displayName = "Claude Code";
+  /** Check if the claude CLI is installed */
+  async isInstalled() {
+    try {
+      await execFileAsync("claude", ["--version"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Get the installed Claude Code version */
+  async getVersion() {
+    try {
+      const { stdout } = await execFileAsync("claude", ["--version"]);
+      return stdout.trim();
+    } catch {
+      return null;
+    }
+  }
+  /** Launch Claude Code in the given working directory with the provided config */
+  async launch(workdir, config) {
+    const args = [];
+    const systemPrompt = await readFile4(config.systemPromptPath, "utf-8");
+    args.push("--append-system-prompt", systemPrompt);
+    args.push("--permission-mode", config.permissionMode ?? "default");
+    args.push("--name", `Interview: ${config.scenarioName}`);
+    if (config.model) {
+      args.push("--model", config.model);
+    }
+    if (config.disallowedTools && config.disallowedTools.length > 0) {
+      args.push("--disallowedTools", ...config.disallowedTools);
+    }
+    const useRecording = config.recording === true;
+    const recorder = useRecording ? new SessionRecorder() : void 0;
+    const proc = spawn("claude", args, {
+      cwd: workdir,
+      stdio: useRecording ? ["inherit", "pipe", "pipe"] : "inherit",
+      env: { ...process.env }
+    });
+    if (useRecording && recorder) {
+      proc.stdout?.on("data", (chunk) => {
+        const text = chunk.toString("utf-8");
+        recorder.record("stdout", text);
+        process.stdout.write(chunk);
+      });
+      proc.stderr?.on("data", (chunk) => {
+        const text = chunk.toString("utf-8");
+        recorder.record("stderr", text);
+        process.stderr.write(chunk);
+      });
+    }
+    return {
+      wait: () => new Promise((resolve) => {
+        proc.on("exit", (code) => resolve({ exitCode: code ?? 0 }));
+      }),
+      kill: async () => {
+        proc.kill("SIGTERM");
+      },
+      recorder
+    };
+  }
+};
+
+// src/launcher/detector.ts
+var launchers = [new ClaudeCodeLauncher()];
+async function detectInstalledTools() {
+  const results = [];
+  for (const launcher of launchers) {
+    const installed = await launcher.isInstalled();
+    if (installed) {
+      const version = await launcher.getVersion();
+      results.push({ launcher, version });
+    }
+  }
+  return results;
+}
+function getLauncher(name) {
+  return launchers.find((l) => l.name === name);
+}
+function getAllLaunchers() {
+  return [...launchers];
+}
+
+// src/session/manager.ts
+import { execSync } from "child_process";
+import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir3, rm } from "fs/promises";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { randomBytes } from "crypto";
+
+// src/session/store.ts
+import { readFile as readFile5, writeFile as writeFile2, readdir as readdir2, unlink, mkdir as mkdir2 } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync4 } from "fs";
+var SESSIONS_DIR = join4(homedir2(), ".vibe-interviewing", "sessions");
+async function ensureSessionsDir() {
+  if (!existsSync4(SESSIONS_DIR)) {
+    await mkdir2(SESSIONS_DIR, { recursive: true });
+  }
+}
+async function saveSession(session) {
+  await ensureSessionsDir();
+  const filePath = join4(SESSIONS_DIR, `${session.id}.json`);
+  await writeFile2(filePath, JSON.stringify(session, null, 2));
+}
+async function loadSession(id) {
+  const filePath = join4(SESSIONS_DIR, `${id}.json`);
+  if (!existsSync4(filePath)) return null;
+  const raw = await readFile5(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+async function deleteSession(id) {
+  const filePath = join4(SESSIONS_DIR, `${id}.json`);
+  if (existsSync4(filePath)) {
+    await unlink(filePath);
+  }
+}
+async function listSessions() {
+  await ensureSessionsDir();
+  const files = await readdir2(SESSIONS_DIR);
+  const sessions = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const raw = await readFile5(join4(SESSIONS_DIR, file), "utf-8");
+      sessions.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+async function listActiveSessions() {
+  const all = await listSessions();
+  return all.filter((s) => s.status !== "complete");
+}
+
+// src/session/types.ts
+function toStoredSession(session) {
+  return {
+    id: session.id,
+    scenarioName: session.scenarioName,
+    status: session.status,
+    workdir: session.workdir,
+    systemPromptPath: session.systemPromptPath,
+    aiTool: session.aiTool,
+    createdAt: session.createdAt,
+    startedAt: session.startedAt,
+    completedAt: session.completedAt
+  };
+}
+
+// src/session/manager.ts
+var SessionManager = class {
+  constructor(launcher) {
+    this.launcher = launcher;
+  }
+  /**
+   * Create a new interview session.
+   *
+   * Flow:
+   * 1. Clone the repo at a pinned commit
+   * 2. Apply bug patches (find/replace in source files)
+   * 3. Wipe git history so the candidate can't diff to find the bug
+   * 4. Remove scenario.yaml from workspace (interviewer-only)
+   * 5. Write BRIEFING.md and system prompt
+   * 6. Run setup commands (npm install, etc.)
+   */
+  async createSession(config, workdir, onProgress) {
+    const id = randomBytes(4).toString("hex");
+    const sessionDir = workdir ?? join5(homedir3(), "vibe-sessions", `${config.name}-${id}`);
+    const session = {
+      id,
+      scenarioName: config.name,
+      workdir: sessionDir,
+      systemPromptPath: "",
+      status: "cloning",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    onProgress?.("Cloning repository...");
+    await importRepo(config.repo, sessionDir, config.commit);
+    onProgress?.("Injecting scenario...");
+    for (const p of config.patch) {
+      const filePath = join5(sessionDir, p.file);
+      const content = await readFile6(filePath, "utf-8");
+      const patched = content.replace(p.find, p.replace);
+      if (patched === content) {
+        throw new SetupError(
+          `patch ${p.file}`,
+          `Could not find text to replace. The upstream code may have changed.`
+        );
+      }
+      await writeFile3(filePath, patched);
+    }
+    onProgress?.("Preparing workspace...");
+    await rm(join5(sessionDir, ".git"), { recursive: true, force: true });
+    execSync('git init && git add -A && git commit -m "initial"', {
+      cwd: sessionDir,
+      stdio: "ignore"
+    });
+    await rm(join5(sessionDir, "scenario.yaml"), { force: true });
+    await writeFile3(join5(sessionDir, "BRIEFING.md"), `# Interview Briefing
+
+${config.briefing}`);
+    const promptDir = join5(homedir3(), ".vibe-interviewing", "prompts");
+    await mkdir3(promptDir, { recursive: true });
+    const systemPromptPath = join5(promptDir, `${id}.md`);
+    await writeFile3(systemPromptPath, generateSystemPrompt(config));
+    session.systemPromptPath = systemPromptPath;
+    session.status = "setting-up";
+    for (const cmd of config.setup) {
+      onProgress?.(`Running: ${cmd}`);
+      try {
+        execSync(cmd, { cwd: sessionDir, stdio: "pipe", timeout: 3e5 });
+      } catch (err) {
+        throw new SetupError(cmd, err instanceof Error ? err.message : String(err));
+      }
+    }
+    session.status = "running";
+    await saveSession(toStoredSession(session));
+    return { session, config };
+  }
+  /** Launch the AI coding tool for an active session */
+  async launchAITool(session, _config, launchConfig = {}) {
+    const fullConfig = {
+      scenarioName: session.scenarioName,
+      systemPromptPath: session.systemPromptPath,
+      ...launchConfig
+    };
+    session.aiTool = this.launcher.name;
+    session.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveSession(toStoredSession(session));
+    const proc = await this.launcher.launch(session.workdir, fullConfig);
+    const result = await proc.wait();
+    session.status = "complete";
+    session.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveSession(toStoredSession(session));
+    return result;
+  }
+  /** Destroy a session by removing its stored data */
+  async destroySession(session) {
+    await deleteSession(session.id);
+  }
+  /** Get elapsed time since the AI tool was launched, formatted as a human-readable string */
+  getElapsedTime(session) {
+    if (!session.startedAt) return null;
+    const elapsed = Date.now() - new Date(session.startedAt).getTime();
+    const minutes = Math.floor(elapsed / 6e4);
+    const seconds = Math.floor(elapsed % 6e4 / 1e3);
+    if (minutes === 0) return `${seconds}s`;
+    return `${minutes}m ${seconds}s`;
+  }
+};
+export {
+  AIToolNotFoundError,
+  ClaudeCodeLauncher,
+  GitCloneError,
+  ScenarioConfigSchema,
+  ScenarioNotFoundError,
+  ScenarioValidationError,
+  SessionManager,
+  SessionNotFoundError,
+  SessionRecorder,
+  SetupError,
+  VibeError,
+  deleteSession,
+  detectInstalledTools,
+  discoverAllScenarios,
+  discoverBuiltInScenarios,
+  generateSystemPrompt,
+  getAllLaunchers,
+  getLauncher,
+  importRepo,
+  listActiveSessions,
+  listSessions,
+  loadScenarioConfig,
+  loadSession,
+  saveSession,
+  toStoredSession,
+  validateScenario,
+  validateScenarioOrThrow
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/scenario/types.ts","../src/scenario/loader.ts","../src/errors.ts","../src/scenario/validator.ts","../src/scenario/registry.ts","../src/scenario/importer.ts","../src/launcher/claude-code.ts","../src/session/recorder.ts","../src/launcher/detector.ts","../src/session/manager.ts","../src/session/store.ts","../src/session/types.ts"],"sourcesContent":["import { z } from 'zod'\n\nconst AIRulesSchema = z.object({\n  /** Role description for the AI assistant */\n  role: z.string(),\n  /** Behavioral rules (e.g., \"don't reveal the answer\") */\n  rules: z.array(z.string()),\n  /** Knowledge about the bug/solution (hidden from candidate) */\n  knowledge: z.string(),\n})\n\nconst EvaluationSchema = z.object({\n  /** Evaluation criteria for the interviewer */\n  criteria: z.array(z.string()),\n  /** Description of the expected fix */\n  expected_fix: z.string().optional(),\n})\n\n/** A file modification to inject the bug */\nconst PatchSchema = z.object({\n  /** Path to the file relative to repo root */\n  file: z.string(),\n  /** The original text to find */\n  find: z.string(),\n  /** The replacement text (with the bug) */\n  replace: z.string(),\n})\n\n/** Full scenario configuration schema */\nexport const ScenarioConfigSchema = z.object({\n  /** Scenario display name */\n  name: z.string(),\n  /** One-line description */\n  description: z.string(),\n  /** Difficulty level */\n  difficulty: z.enum(['easy', 'medium', 'hard']),\n  /** Estimated time (e.g., \"30-45m\") */\n  estimated_time: z.string(),\n  /** Searchable tags */\n  tags: z.array(z.string()).default([]),\n\n  /** GitHub repo URL or owner/repo shorthand */\n  repo: z.string(),\n  /** Commit SHA to pin the clone to (ensures reproducibility) */\n  commit: z.string(),\n  /** Shell commands to run after cloning (e.g., [\"npm install\"]) */\n  setup: z.array(z.string()).default([]),\n\n  /** Find-and-replace patches to inject the bug after cloning */\n  patch: z.array(PatchSchema).default([]),\n\n  /** Briefing shown to the candidate (written like a team lead message) */\n  briefing: z.string(),\n  /** AI behavioral rules (injected via system prompt, hidden from candidate) */\n  ai_rules: AIRulesSchema,\n  /** Interviewer reference — what the fix looks like */\n  solution: z.string(),\n\n  /** Evaluation rubric */\n  evaluation: EvaluationSchema.optional(),\n  /** License of the original project */\n  license: z.string().optional(),\n})\n\nexport type ScenarioConfig = z.infer<typeof ScenarioConfigSchema>\nexport type AIRules = z.infer<typeof AIRulesSchema>\nexport type Evaluation = z.infer<typeof EvaluationSchema>\n\n/** Metadata about a discovered scenario */\nexport interface ScenarioInfo {\n  /** Scenario name */\n  name: string\n  /** Parsed config */\n  config: ScenarioConfig\n  /** Whether this is a built-in scenario */\n  builtIn: boolean\n}\n","import { readFile } from 'node:fs/promises'\nimport { parse as parseYaml } from 'yaml'\nimport { ScenarioNotFoundError, ScenarioValidationError } from '../errors.js'\nimport { ScenarioConfigSchema, type ScenarioConfig } from './types.js'\nimport { existsSync } from 'node:fs'\n\n/**\n * Load and parse a scenario config from a YAML file.\n *\n * @param configPath - Absolute path to the scenario.yaml file\n * @returns The parsed and validated scenario config\n */\nexport async function loadScenarioConfig(configPath: string): Promise<ScenarioConfig> {\n  if (!existsSync(configPath)) {\n    throw new ScenarioNotFoundError(configPath)\n  }\n\n  const raw = await readFile(configPath, 'utf-8')\n  const parsed: unknown = parseYaml(raw)\n\n  const result = ScenarioConfigSchema.safeParse(parsed)\n  if (!result.success) {\n    const issues = result.error.issues.map((i) => `  ${i.path.join('.')}: ${i.message}`)\n    throw new ScenarioValidationError('validation failed', issues)\n  }\n\n  return result.data\n}\n\n/**\n * Generate a system prompt string from a scenario's ai_rules.\n *\n * This prompt is injected into the AI tool via --append-system-prompt\n * and is hidden from the candidate.\n *\n * @param config - The scenario config containing ai_rules\n * @returns The formatted system prompt\n */\nexport function generateSystemPrompt(config: ScenarioConfig): string {\n  const lines: string[] = []\n\n  lines.push(`# Interview Scenario: ${config.name}`)\n  lines.push('')\n  lines.push('## Your Role')\n  lines.push(config.ai_rules.role.trim())\n  lines.push('')\n  lines.push('## Rules')\n  for (const rule of config.ai_rules.rules) {\n    lines.push(`- ${rule}`)\n  }\n  lines.push('')\n  lines.push('## Knowledge (DO NOT share directly with the candidate)')\n  lines.push(config.ai_rules.knowledge.trim())\n\n  return lines.join('\\n')\n}\n","/** Base error class for all vibe-interviewing errors */\nexport class VibeError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly hint?: string,\n  ) {\n    super(message)\n    this.name = 'VibeError'\n  }\n}\n\nexport class ScenarioNotFoundError extends VibeError {\n  constructor(name: string) {\n    super(\n      `Scenario not found: ${name}`,\n      'SCENARIO_NOT_FOUND',\n      'Run `vibe-interviewing list` to see available scenarios',\n    )\n  }\n}\n\nexport class ScenarioValidationError extends VibeError {\n  constructor(\n    message: string,\n    public readonly issues: string[],\n  ) {\n    super(`Invalid scenario config: ${message}`, 'SCENARIO_VALIDATION_ERROR', issues.join('\\n'))\n  }\n}\n\nexport class AIToolNotFoundError extends VibeError {\n  static readonly installHints: Record<string, string> = {\n    'claude-code': 'Install Claude Code: npm install -g @anthropic-ai/claude-code',\n  }\n\n  constructor(tool: string) {\n    super(\n      `${tool} is not installed`,\n      'AI_TOOL_NOT_FOUND',\n      AIToolNotFoundError.installHints[tool] ?? `Install ${tool} and try again`,\n    )\n  }\n}\n\nexport class SessionNotFoundError extends VibeError {\n  constructor(id: string) {\n    super(\n      `Session not found: ${id}`,\n      'SESSION_NOT_FOUND',\n      'Run `vibe-interviewing list` to see active sessions',\n    )\n  }\n}\n\nexport class GitCloneError extends VibeError {\n  constructor(repo: string, reason?: string) {\n    super(\n      `Failed to clone repository: ${repo}${reason ? ` — ${reason}` : ''}`,\n      'GIT_CLONE_FAILED',\n      'Check the repo URL and your network connection',\n    )\n  }\n}\n\nexport class SetupError extends VibeError {\n  constructor(command: string, reason?: string) {\n    super(\n      `Setup command failed: ${command}${reason ? ` — ${reason}` : ''}`,\n      'SETUP_FAILED',\n      'Check the scenario setup commands and try again',\n    )\n  }\n}\n","import { ScenarioValidationError } from '../errors.js'\nimport type { ScenarioConfig } from './types.js'\n\n/** Result of validating a scenario configuration */\nexport interface ValidationResult {\n  /** Whether the scenario is valid (no errors) */\n  valid: boolean\n  /** Non-fatal issues that should be addressed */\n  warnings: string[]\n  /** Fatal issues that prevent the scenario from running */\n  errors: string[]\n}\n\n/**\n * Validate a scenario config for completeness and correctness.\n *\n * @param config - The scenario config to validate\n * @returns Validation result with errors and warnings\n */\nexport async function validateScenario(config: ScenarioConfig): Promise<ValidationResult> {\n  const warnings: string[] = []\n  const errors: string[] = []\n\n  // Check briefing is not empty\n  if (!config.briefing.trim()) {\n    errors.push('Briefing cannot be empty')\n  }\n\n  // Check AI rules\n  if (!config.ai_rules.role.trim()) {\n    errors.push('ai_rules.role cannot be empty')\n  }\n\n  // Check repo is not empty\n  if (!config.repo.trim()) {\n    errors.push('repo cannot be empty')\n  }\n\n  // Check commit is pinned\n  if (!config.commit.trim()) {\n    errors.push('commit cannot be empty — pin to a specific commit SHA for reproducibility')\n  }\n\n  // Warnings for non-critical missing content\n  if (config.ai_rules.rules.length === 0) {\n    warnings.push('ai_rules.rules is empty — the AI will have no behavioral constraints')\n  }\n\n  if (!config.solution.trim()) {\n    warnings.push('solution is empty — interviewers will have no solution reference')\n  }\n\n  if (!config.evaluation) {\n    warnings.push('No evaluation criteria defined')\n  }\n\n  return {\n    valid: errors.length === 0,\n    warnings,\n    errors,\n  }\n}\n\n/**\n * Validate a scenario config and throw if invalid.\n *\n * @param config - The scenario config to validate\n * @returns Validation result (only returned if valid)\n * @throws ScenarioValidationError if the config has errors\n */\nexport async function validateScenarioOrThrow(config: ScenarioConfig): Promise<ValidationResult> {\n  const result = await validateScenario(config)\n  if (!result.valid) {\n    throw new ScenarioValidationError('scenario validation failed', result.errors)\n  }\n  return result\n}\n","import { readFile } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { existsSync } from 'node:fs'\nimport { parse as parseYaml } from 'yaml'\nimport { loadScenarioConfig } from './loader.js'\nimport type { ScenarioInfo } from './types.js'\n\n/** Shape of a single entry in registry.yaml */\ninterface RegistryEntry {\n  name: string\n  repo: string\n  commit: string\n  description: string\n  difficulty: 'easy' | 'medium' | 'hard'\n  estimated_time: string\n}\n\n/** Shape of the registry.yaml file */\ninterface RegistryFile {\n  scenarios: RegistryEntry[]\n}\n\n/**\n * Get the path to the scenarios package directory.\n *\n * Resolves via the @vibe-interviewing/scenarios package, which works both\n * in the monorepo (workspace link) and when installed from npm.\n */\nasync function getScenariosPackagePath(): Promise<string> {\n  try {\n    const { getScenariosDir } = await import('@vibe-interviewing/scenarios')\n    return getScenariosDir()\n  } catch {\n    // Fallback: try relative to process.cwd() (monorepo root)\n    const fromCwd = join(process.cwd(), 'packages', 'scenarios')\n    if (existsSync(fromCwd)) {\n      return fromCwd\n    }\n    throw new Error('Could not locate @vibe-interviewing/scenarios package')\n  }\n}\n\n/**\n * Discover built-in scenarios from the registry.yaml file in the scenarios package.\n *\n * Each entry in the registry points to a scenario directory containing a full\n * scenario.yaml. The registry provides quick lookup metadata, while the full\n * config is loaded from the scenario's own config file.\n *\n * @returns Array of discovered scenario info objects\n */\nexport async function discoverBuiltInScenarios(): Promise<ScenarioInfo[]> {\n  const scenariosPath = await getScenariosPackagePath()\n  const registryPath = join(scenariosPath, 'registry.yaml')\n\n  if (!existsSync(registryPath)) {\n    return []\n  }\n\n  const raw = await readFile(registryPath, 'utf-8')\n  const registry = parseYaml(raw) as RegistryFile\n\n  if (!registry.scenarios || !Array.isArray(registry.scenarios)) {\n    return []\n  }\n\n  const scenarios: ScenarioInfo[] = []\n\n  for (const entry of registry.scenarios) {\n    // Load the full config from the scenario's own directory\n    const scenarioConfigPath = join(scenariosPath, entry.name, 'scenario.yaml')\n\n    if (existsSync(scenarioConfigPath)) {\n      const config = await loadScenarioConfig(scenarioConfigPath)\n      scenarios.push({\n        name: entry.name,\n        config,\n        builtIn: true,\n      })\n    }\n  }\n\n  return scenarios\n}\n\n/**\n * Discover all available scenarios.\n *\n * Currently returns only built-in scenarios from the registry.\n * Local scenario support can be added later.\n *\n * @returns Array of all discovered scenario info objects\n */\nexport async function discoverAllScenarios(): Promise<ScenarioInfo[]> {\n  return discoverBuiltInScenarios()\n}\n","import { mkdtemp } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { tmpdir } from 'node:os'\nimport { GitCloneError } from '../errors.js'\n\n/**\n * Import a repository by cloning it to a local directory.\n *\n * For commit SHAs, uses a shallow fetch to avoid downloading full history.\n *\n * @param repoUrl - GitHub URL, SSH URL, or owner/repo shorthand\n * @param targetPath - Directory to clone into (defaults to a temp directory)\n * @param ref - Optional branch, tag, or commit to checkout\n * @returns The path to the cloned directory\n */\nexport async function importRepo(repoUrl: string, targetPath?: string, ref?: string): Promise<string> {\n  const { simpleGit } = await import('simple-git')\n\n  // Normalize shorthand (owner/repo -> https://github.com/owner/repo)\n  const url = normalizeRepoUrl(repoUrl)\n\n  // Clone to target path or temp directory\n  const dest = targetPath ?? (await mkdtemp(join(tmpdir(), 'vibe-import-')))\n\n  const git = simpleGit()\n\n  try {\n    if (ref && /^[0-9a-f]{7,40}$/i.test(ref)) {\n      // Commit SHA — init + shallow fetch to avoid downloading full history\n      await git.init([dest])\n      const repoGit = simpleGit(dest)\n      await repoGit.addRemote('origin', url)\n      await repoGit.fetch(['origin', ref, '--depth', '1'])\n      await repoGit.checkout(['FETCH_HEAD'])\n    } else if (ref) {\n      // Branch or tag — shallow clone\n      await git.clone(url, dest, ['--depth', '1', '--branch', ref])\n    } else {\n      await git.clone(url, dest, ['--depth', '1'])\n    }\n  } catch (err) {\n    throw new GitCloneError(url, err instanceof Error ? err.message : String(err))\n  }\n\n  return dest\n}\n\n/** Normalize various repo URL formats to full HTTPS URLs */\nfunction normalizeRepoUrl(input: string): string {\n  // Already a full URL\n  if (input.startsWith('http://') || input.startsWith('https://')) {\n    return input\n  }\n\n  // Git SSH format\n  if (input.startsWith('git@')) {\n    return input.replace('git@github.com:', 'https://github.com/').replace(/\\.git$/, '')\n  }\n\n  // Shorthand: owner/repo\n  if (/^[a-zA-Z0-9_-]+\\/[a-zA-Z0-9._-]+$/.test(input)) {\n    return `https://github.com/${input}`\n  }\n\n  return input\n}\n","import { spawn } from 'node:child_process'\nimport { execFile } from 'node:child_process'\nimport { promisify } from 'node:util'\nimport { readFile } from 'node:fs/promises'\nimport type { AIToolLauncher, LaunchConfig, LaunchedProcess } from './types.js'\nimport { SessionRecorder } from '../session/recorder.js'\n\nconst execFileAsync = promisify(execFile)\n\n/** Launcher for Anthropic's Claude Code CLI */\nexport class ClaudeCodeLauncher implements AIToolLauncher {\n  readonly name = 'claude-code'\n  readonly displayName = 'Claude Code'\n\n  /** Check if the claude CLI is installed */\n  async isInstalled(): Promise<boolean> {\n    try {\n      await execFileAsync('claude', ['--version'])\n      return true\n    } catch {\n      return false\n    }\n  }\n\n  /** Get the installed Claude Code version */\n  async getVersion(): Promise<string | null> {\n    try {\n      const { stdout } = await execFileAsync('claude', ['--version'])\n      return stdout.trim()\n    } catch {\n      return null\n    }\n  }\n\n  /** Launch Claude Code in the given working directory with the provided config */\n  async launch(workdir: string, config: LaunchConfig): Promise<LaunchedProcess> {\n    const args: string[] = []\n\n    // Inject hidden system prompt\n    const systemPrompt = await readFile(config.systemPromptPath, 'utf-8')\n    args.push('--append-system-prompt', systemPrompt)\n\n    // Set permission mode\n    args.push('--permission-mode', config.permissionMode ?? 'default')\n\n    // Set session name\n    args.push('--name', `Interview: ${config.scenarioName}`)\n\n    // Set model if specified\n    if (config.model) {\n      args.push('--model', config.model)\n    }\n\n    // Disallow tools for fairness\n    if (config.disallowedTools && config.disallowedTools.length > 0) {\n      args.push('--disallowedTools', ...config.disallowedTools)\n    }\n\n    // When recording, pipe stdout/stderr through the recorder\n    const useRecording = config.recording === true\n    const recorder = useRecording ? new SessionRecorder() : undefined\n\n    // Spawn claude process\n    const proc = spawn('claude', args, {\n      cwd: workdir,\n      stdio: useRecording ? ['inherit', 'pipe', 'pipe'] : 'inherit',\n      env: { ...process.env },\n    })\n\n    // Forward piped output to the terminal and record it\n    if (useRecording && recorder) {\n      proc.stdout?.on('data', (chunk: Buffer) => {\n        const text = chunk.toString('utf-8')\n        recorder.record('stdout', text)\n        process.stdout.write(chunk)\n      })\n\n      proc.stderr?.on('data', (chunk: Buffer) => {\n        const text = chunk.toString('utf-8')\n        recorder.record('stderr', text)\n        process.stderr.write(chunk)\n      })\n    }\n\n    return {\n      wait: () =>\n        new Promise((resolve) => {\n          proc.on('exit', (code) => resolve({ exitCode: code ?? 0 }))\n        }),\n      kill: async () => {\n        proc.kill('SIGTERM')\n      },\n      recorder,\n    }\n  }\n}\n","import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { homedir } from 'node:os'\nimport { existsSync } from 'node:fs'\n\n/** Event types that can be captured during a session */\nexport type SessionEventType = 'stdout' | 'stderr' | 'command' | 'note'\n\n/** A single timestamped event captured during a session */\nexport interface SessionEvent {\n  /** Milliseconds since recording started */\n  timestamp: number\n  /** The kind of event */\n  type: SessionEventType\n  /** The captured data */\n  data: string\n}\n\n/** Serialized recording format */\nexport interface RecordingData {\n  /** Session ID this recording belongs to */\n  sessionId: string\n  /** ISO string of when recording started */\n  startedAt: string\n  /** All captured events */\n  events: SessionEvent[]\n}\n\nconst RECORDINGS_DIR = join(homedir(), '.vibe-interviewing', 'recordings')\n\nasync function ensureRecordingsDir(): Promise<void> {\n  if (!existsSync(RECORDINGS_DIR)) {\n    await mkdir(RECORDINGS_DIR, { recursive: true })\n  }\n}\n\n/**\n * Records timestamped events during an interview session.\n *\n * Captures stdout, stderr, commands, and notes with millisecond timestamps\n * relative to when the recorder was created.\n */\nexport class SessionRecorder {\n  private readonly events: SessionEvent[] = []\n  private readonly startTime: number\n  private readonly startedAt: string\n\n  constructor() {\n    this.startTime = Date.now()\n    this.startedAt = new Date().toISOString()\n  }\n\n  /** Record a timestamped event */\n  record(type: SessionEventType, data: string): void {\n    this.events.push({\n      timestamp: Date.now() - this.startTime,\n      type,\n      data,\n    })\n  }\n\n  /** Get all recorded events */\n  getEvents(): ReadonlyArray<SessionEvent> {\n    return this.events\n  }\n\n  /** Serialize the recording to a JSON-compatible object */\n  toJSON(sessionId: string): RecordingData {\n    return {\n      sessionId,\n      startedAt: this.startedAt,\n      events: [...this.events],\n    }\n  }\n\n  /** Create a SessionRecorder pre-populated with events from serialized data */\n  static fromJSON(data: RecordingData): SessionRecorder {\n    const recorder = new SessionRecorder()\n    // Override the startedAt via Object.defineProperty since it's readonly\n    Object.defineProperty(recorder, 'startedAt', { value: data.startedAt })\n    for (const event of data.events) {\n      recorder.events.push({ ...event })\n    }\n    return recorder\n  }\n\n  /** Save the recording to disk */\n  async save(sessionId: string): Promise<void> {\n    await ensureRecordingsDir()\n    const filePath = join(RECORDINGS_DIR, `${sessionId}.json`)\n    const data = this.toJSON(sessionId)\n    await writeFile(filePath, JSON.stringify(data, null, 2))\n  }\n\n  /** Load a recording from disk */\n  static async load(sessionId: string): Promise<SessionRecorder> {\n    const filePath = join(RECORDINGS_DIR, `${sessionId}.json`)\n    const raw = await readFile(filePath, 'utf-8')\n    const data = JSON.parse(raw) as RecordingData\n    return SessionRecorder.fromJSON(data)\n  }\n\n  /** List all available recording session IDs */\n  static async list(): Promise<string[]> {\n    await ensureRecordingsDir()\n    const files = await readdir(RECORDINGS_DIR)\n    return files\n      .filter((f) => f.endsWith('.json'))\n      .map((f) => f.replace(/\\.json$/, ''))\n      .sort()\n  }\n}\n","import { ClaudeCodeLauncher } from './claude-code.js'\nimport type { AIToolLauncher } from './types.js'\n\n/** All supported AI tool launchers */\nconst launchers: AIToolLauncher[] = [new ClaudeCodeLauncher()]\n\n/** Information about a detected AI coding tool */\nexport interface DetectedTool {\n  /** The launcher instance */\n  launcher: AIToolLauncher\n  /** Installed version string, or null if unknown */\n  version: string | null\n}\n\n/** Detect which AI coding tools are installed on the system */\nexport async function detectInstalledTools(): Promise<DetectedTool[]> {\n  const results: DetectedTool[] = []\n\n  for (const launcher of launchers) {\n    const installed = await launcher.isInstalled()\n    if (installed) {\n      const version = await launcher.getVersion()\n      results.push({ launcher, version })\n    }\n  }\n\n  return results\n}\n\n/** Get a launcher by its internal name */\nexport function getLauncher(name: string): AIToolLauncher | undefined {\n  return launchers.find((l) => l.name === name)\n}\n\n/** Get all registered launchers */\nexport function getAllLaunchers(): AIToolLauncher[] {\n  return [...launchers]\n}\n","import { execSync } from 'node:child_process'\nimport { readFile, writeFile, mkdir, rm } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { homedir } from 'node:os'\nimport { randomBytes } from 'node:crypto'\nimport type { AIToolLauncher, LaunchConfig } from '../launcher/types.js'\nimport type { ScenarioConfig } from '../scenario/types.js'\nimport { importRepo } from '../scenario/importer.js'\nimport { generateSystemPrompt } from '../scenario/loader.js'\nimport { SetupError } from '../errors.js'\nimport { saveSession, deleteSession } from './store.js'\nimport { toStoredSession } from './types.js'\nimport type { Session } from './types.js'\n\nexport type { Session }\n\n/** Callback for reporting session progress */\nexport type ProgressCallback = (stage: string) => void\n\n/** Manages the lifecycle of an interview session */\nexport class SessionManager {\n  constructor(private launcher: AIToolLauncher) {}\n\n  /**\n   * Create a new interview session.\n   *\n   * Flow:\n   * 1. Clone the repo at a pinned commit\n   * 2. Apply bug patches (find/replace in source files)\n   * 3. Wipe git history so the candidate can't diff to find the bug\n   * 4. Remove scenario.yaml from workspace (interviewer-only)\n   * 5. Write BRIEFING.md and system prompt\n   * 6. Run setup commands (npm install, etc.)\n   */\n  async createSession(\n    config: ScenarioConfig,\n    workdir?: string,\n    onProgress?: ProgressCallback,\n  ): Promise<{ session: Session; config: ScenarioConfig }> {\n    const id = randomBytes(4).toString('hex')\n    const sessionDir = workdir ?? join(homedir(), 'vibe-sessions', `${config.name}-${id}`)\n\n    const session: Session = {\n      id,\n      scenarioName: config.name,\n      workdir: sessionDir,\n      systemPromptPath: '',\n      status: 'cloning',\n      createdAt: new Date().toISOString(),\n    }\n\n    // 1. Clone the repo at the pinned commit\n    onProgress?.('Cloning repository...')\n    await importRepo(config.repo, sessionDir, config.commit)\n\n    // 2. Apply bug patches\n    onProgress?.('Injecting scenario...')\n    for (const p of config.patch) {\n      const filePath = join(sessionDir, p.file)\n      const content = await readFile(filePath, 'utf-8')\n      const patched = content.replace(p.find, p.replace)\n      if (patched === content) {\n        throw new SetupError(\n          `patch ${p.file}`,\n          `Could not find text to replace. The upstream code may have changed.`,\n        )\n      }\n      await writeFile(filePath, patched)\n    }\n\n    // 3. Wipe git history so candidate can't see the injected changes\n    onProgress?.('Preparing workspace...')\n    await rm(join(sessionDir, '.git'), { recursive: true, force: true })\n    execSync('git init && git add -A && git commit -m \"initial\"', {\n      cwd: sessionDir,\n      stdio: 'ignore',\n    })\n\n    // 4. Remove scenario.yaml from workspace (interviewer-only data)\n    await rm(join(sessionDir, 'scenario.yaml'), { force: true })\n\n    // 5. Write BRIEFING.md\n    await writeFile(join(sessionDir, 'BRIEFING.md'), `# Interview Briefing\\n\\n${config.briefing}`)\n\n    // Write system prompt OUTSIDE the workspace\n    const promptDir = join(homedir(), '.vibe-interviewing', 'prompts')\n    await mkdir(promptDir, { recursive: true })\n    const systemPromptPath = join(promptDir, `${id}.md`)\n    await writeFile(systemPromptPath, generateSystemPrompt(config))\n    session.systemPromptPath = systemPromptPath\n\n    // 6. Run setup commands\n    session.status = 'setting-up'\n    for (const cmd of config.setup) {\n      onProgress?.(`Running: ${cmd}`)\n      try {\n        execSync(cmd, { cwd: sessionDir, stdio: 'pipe', timeout: 300000 })\n      } catch (err) {\n        throw new SetupError(cmd, err instanceof Error ? err.message : String(err))\n      }\n    }\n\n    session.status = 'running'\n    await saveSession(toStoredSession(session))\n    return { session, config }\n  }\n\n  /** Launch the AI coding tool for an active session */\n  async launchAITool(\n    session: Session,\n    _config: ScenarioConfig,\n    launchConfig: Partial<LaunchConfig> = {},\n  ): Promise<{ exitCode: number }> {\n    const fullConfig: LaunchConfig = {\n      scenarioName: session.scenarioName,\n      systemPromptPath: session.systemPromptPath,\n      ...launchConfig,\n    }\n\n    session.aiTool = this.launcher.name\n    session.startedAt = new Date().toISOString()\n    await saveSession(toStoredSession(session))\n\n    const proc = await this.launcher.launch(session.workdir, fullConfig)\n    const result = await proc.wait()\n\n    session.status = 'complete'\n    session.completedAt = new Date().toISOString()\n    await saveSession(toStoredSession(session))\n\n    return result\n  }\n\n  /** Destroy a session by removing its stored data */\n  async destroySession(session: Session): Promise<void> {\n    await deleteSession(session.id)\n  }\n\n  /** Get elapsed time since the AI tool was launched, formatted as a human-readable string */\n  getElapsedTime(session: Session): string | null {\n    if (!session.startedAt) return null\n\n    const elapsed = Date.now() - new Date(session.startedAt).getTime()\n    const minutes = Math.floor(elapsed / 60000)\n    const seconds = Math.floor((elapsed % 60000) / 1000)\n\n    if (minutes === 0) return `${seconds}s`\n    return `${minutes}m ${seconds}s`\n  }\n}\n","import { readFile, writeFile, readdir, unlink, mkdir } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { homedir } from 'node:os'\nimport { existsSync } from 'node:fs'\nimport type { StoredSession } from './types.js'\n\nconst SESSIONS_DIR = join(homedir(), '.vibe-interviewing', 'sessions')\n\nasync function ensureSessionsDir(): Promise<void> {\n  if (!existsSync(SESSIONS_DIR)) {\n    await mkdir(SESSIONS_DIR, { recursive: true })\n  }\n}\n\n/** Save a session to disk */\nexport async function saveSession(session: StoredSession): Promise<void> {\n  await ensureSessionsDir()\n  const filePath = join(SESSIONS_DIR, `${session.id}.json`)\n  await writeFile(filePath, JSON.stringify(session, null, 2))\n}\n\n/** Load a session from disk */\nexport async function loadSession(id: string): Promise<StoredSession | null> {\n  const filePath = join(SESSIONS_DIR, `${id}.json`)\n  if (!existsSync(filePath)) return null\n\n  const raw = await readFile(filePath, 'utf-8')\n  return JSON.parse(raw) as StoredSession\n}\n\n/** Delete a session from disk */\nexport async function deleteSession(id: string): Promise<void> {\n  const filePath = join(SESSIONS_DIR, `${id}.json`)\n  if (existsSync(filePath)) {\n    await unlink(filePath)\n  }\n}\n\n/** List all stored sessions */\nexport async function listSessions(): Promise<StoredSession[]> {\n  await ensureSessionsDir()\n  const files = await readdir(SESSIONS_DIR)\n  const sessions: StoredSession[] = []\n\n  for (const file of files) {\n    if (!file.endsWith('.json')) continue\n    try {\n      const raw = await readFile(join(SESSIONS_DIR, file), 'utf-8')\n      sessions.push(JSON.parse(raw) as StoredSession)\n    } catch {\n      // Skip corrupted files\n    }\n  }\n\n  return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())\n}\n\n/** List only active (non-complete) sessions */\nexport async function listActiveSessions(): Promise<StoredSession[]> {\n  const all = await listSessions()\n  return all.filter((s) => s.status !== 'complete')\n}\n","/** Status of an interview session */\nexport type SessionStatus = 'cloning' | 'setting-up' | 'running' | 'complete'\n\n/** A live interview session */\nexport interface Session {\n  /** Unique session identifier */\n  id: string\n  /** Name of the scenario being run */\n  scenarioName: string\n  /** Local working directory for the candidate */\n  workdir: string\n  /** Path to the system prompt file (outside workspace) */\n  systemPromptPath: string\n  /** Current session status */\n  status: SessionStatus\n  /** ISO timestamp of session creation */\n  createdAt: string\n  /** ISO timestamp of when the AI tool was launched */\n  startedAt?: string\n  /** ISO timestamp of session completion */\n  completedAt?: string\n  /** Name of the AI tool used */\n  aiTool?: string\n}\n\n/** Serializable session data for persistence */\nexport interface StoredSession {\n  /** Unique session identifier */\n  id: string\n  /** Name of the scenario being run */\n  scenarioName: string\n  /** Current session status */\n  status: SessionStatus\n  /** Local working directory for the candidate */\n  workdir: string\n  /** Path to the system prompt file */\n  systemPromptPath: string\n  /** Name of the AI tool used */\n  aiTool?: string\n  /** ISO timestamp of session creation */\n  createdAt: string\n  /** ISO timestamp of when the AI tool was launched */\n  startedAt?: string\n  /** ISO timestamp of session completion */\n  completedAt?: string\n}\n\n/** Convert a Session to a StoredSession for persistence */\nexport function toStoredSession(session: Session): StoredSession {\n  return {\n    id: session.id,\n    scenarioName: session.scenarioName,\n    status: session.status,\n    workdir: session.workdir,\n    systemPromptPath: session.systemPromptPath,\n    aiTool: session.aiTool,\n    createdAt: session.createdAt,\n    startedAt: session.startedAt,\n    completedAt: session.completedAt,\n  }\n}\n"],"mappings":"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","names":["readFile","existsSync","parseYaml","existsSync","readFile","parseYaml","join","join","readFile","readFile","join","existsSync","readFile","readFile","writeFile","mkdir","join","homedir","readFile","writeFile","readdir","mkdir","join","homedir","existsSync","join","homedir","readFile","writeFile","mkdir"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@vibe-interviewing/core",
+  "version": "0.1.0",
+  "description": "Core library for vibe-interviewing — scenario engine, session management, AI tool launchers",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "simple-git": "^3.27.0",
+    "yaml": "^2.7.0",
+    "zod": "^3.24.0",
+    "@vibe-interviewing/scenarios": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "license": "MIT",
+  "files": [
+    "dist/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cpaczek/vibe-interviewing.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/cpaczek/vibe-interviewing#readme",
+  "bugs": {
+    "url": "https://github.com/cpaczek/vibe-interviewing/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  }
+}