@opengsd/get-shit-done-redux 1.0.0

package/sdk/src/query/profile-questionnaire-data.ts

@@ -0,0 +1,181 @@
+/**
+ * Synced from get-shit-done/bin/lib/profile-output.cjs (PROFILING_QUESTIONS, CLAUDE_INSTRUCTIONS).
+ * Used by profileQuestionnaire for parity with cmdProfileQuestionnaire.
+ */
+
+export type ProfilingOption = { label: string; value: string; rating: string };
+
+export type ProfilingQuestion = {
+  dimension: string;
+  header: string;
+  context: string;
+  question: string;
+  options: ProfilingOption[];
+};
+
+export const PROFILING_QUESTIONS: ProfilingQuestion[] = [
+  {
+    dimension: 'communication_style',
+    header: 'Communication Style',
+    context: 'Think about the last few times you asked Claude to build or change something. How did you frame the request?',
+    question: 'When you ask Claude to build something, how much context do you typically provide?',
+    options: [
+      { label: 'Minimal -- "fix the bug", "add dark mode", just say what\'s needed', value: 'a', rating: 'terse-direct' },
+      { label: 'Some context -- explain what and why in a paragraph or two', value: 'b', rating: 'conversational' },
+      { label: 'Detailed specs -- headers, numbered lists, problem analysis, constraints', value: 'c', rating: 'detailed-structured' },
+      { label: 'It depends on the task -- simple tasks get short prompts, complex ones get detailed specs', value: 'd', rating: 'mixed' },
+    ],
+  },
+  {
+    dimension: 'decision_speed',
+    header: 'Decision Making',
+    context: 'Think about times when Claude presented you with multiple options -- like choosing a library, picking an architecture, or selecting an approach.',
+    question: 'When Claude presents you with options, how do you typically decide?',
+    options: [
+      { label: 'Pick quickly based on gut feeling or past experience', value: 'a', rating: 'fast-intuitive' },
+      { label: 'Ask for a comparison table or pros/cons, then decide', value: 'b', rating: 'deliberate-informed' },
+      { label: 'Research independently (read docs, check GitHub stars) before deciding', value: 'c', rating: 'research-first' },
+      { label: 'Let Claude recommend -- I generally trust the suggestion', value: 'd', rating: 'delegator' },
+    ],
+  },
+  {
+    dimension: 'explanation_depth',
+    header: 'Explanation Preferences',
+    context: 'Think about when Claude explains code it wrote or an approach it took. How much detail feels right?',
+    question: 'When Claude explains something, how much detail do you want?',
+    options: [
+      { label: 'Just the code -- I\'ll read it and figure it out myself', value: 'a', rating: 'code-only' },
+      { label: 'Brief explanation with the code -- a sentence or two about the approach', value: 'b', rating: 'concise' },
+      { label: 'Detailed walkthrough -- explain the approach, trade-offs, and code structure', value: 'c', rating: 'detailed' },
+      { label: 'Deep dive -- teach me the concepts behind it so I understand the fundamentals', value: 'd', rating: 'educational' },
+    ],
+  },
+  {
+    dimension: 'debugging_approach',
+    header: 'Debugging Style',
+    context: 'Think about the last few times something broke in your code. How did you approach it with Claude?',
+    question: 'When something breaks, how do you typically approach debugging with Claude?',
+    options: [
+      { label: 'Paste the error and say "fix it" -- get it working fast', value: 'a', rating: 'fix-first' },
+      { label: 'Share the error plus context, ask Claude to diagnose what went wrong', value: 'b', rating: 'diagnostic' },
+      { label: 'Investigate myself first, then ask Claude about my specific theories', value: 'c', rating: 'hypothesis-driven' },
+      { label: 'Walk through the code together step by step to understand the issue', value: 'd', rating: 'collaborative' },
+    ],
+  },
+  {
+    dimension: 'ux_philosophy',
+    header: 'UX Philosophy',
+    context: 'Think about user-facing features you have built recently. How did you balance functionality with design?',
+    question: 'When building user-facing features, what do you prioritize?',
+    options: [
+      { label: 'Get it working first, polish the UI later (or never)', value: 'a', rating: 'function-first' },
+      { label: 'Basic usability from the start -- nothing ugly, but no pixel-perfection', value: 'b', rating: 'pragmatic' },
+      { label: 'Design and UX are as important as functionality -- I care about the experience', value: 'c', rating: 'design-conscious' },
+      { label: 'I mostly build backend, CLI, or infrastructure -- UX is minimal', value: 'd', rating: 'backend-focused' },
+    ],
+  },
+  {
+    dimension: 'vendor_philosophy',
+    header: 'Library & Vendor Choices',
+    context: 'Think about the last time you needed a library or service for a project. How did you go about choosing it?',
+    question: 'When choosing libraries or services, what is your typical approach?',
+    options: [
+      { label: 'Use whatever Claude suggests -- speed matters more than the perfect choice', value: 'a', rating: 'pragmatic-fast' },
+      { label: 'Prefer well-known, battle-tested options (React, PostgreSQL, Express)', value: 'b', rating: 'conservative' },
+      { label: 'Research alternatives, read docs, compare benchmarks before committing', value: 'c', rating: 'thorough-evaluator' },
+      { label: 'Strong opinions -- I already know what I like and I stick with it', value: 'd', rating: 'opinionated' },
+    ],
+  },
+  {
+    dimension: 'frustration_triggers',
+    header: 'Frustration Triggers',
+    context: 'Think about moments when working with AI coding assistants that made you frustrated or annoyed.',
+    question: 'What frustrates you most when working with AI coding assistants?',
+    options: [
+      { label: 'Doing things I didn\'t ask for -- adding features, refactoring code, scope creep', value: 'a', rating: 'scope-creep' },
+      { label: 'Not following instructions precisely -- ignoring constraints or requirements I stated', value: 'b', rating: 'instruction-adherence' },
+      { label: 'Over-explaining or being too verbose -- just give me the code and move on', value: 'c', rating: 'verbosity' },
+      { label: 'Breaking working code while fixing something else -- regressions', value: 'd', rating: 'regression' },
+    ],
+  },
+  {
+    dimension: 'learning_style',
+    header: 'Learning Preferences',
+    context: 'Think about encountering something new -- an unfamiliar library, a codebase you inherited, a concept you hadn\'t used before.',
+    question: 'When you encounter something new in your codebase, how do you prefer to learn about it?',
+    options: [
+      { label: 'Read the code directly -- I figure things out by reading and experimenting', value: 'a', rating: 'self-directed' },
+      { label: 'Ask Claude to explain the relevant parts to me', value: 'b', rating: 'guided' },
+      { label: 'Read official docs and tutorials first, then try things', value: 'c', rating: 'documentation-first' },
+      { label: 'See a working example, then modify it to understand how it works', value: 'd', rating: 'example-driven' },
+    ],
+  },
+];
+
+export const CLAUDE_INSTRUCTIONS: Record<string, Record<string, string>> = {
+  communication_style: {
+    'terse-direct': 'Keep responses concise and action-oriented. Skip lengthy preambles. Match this developer\'s direct style.',
+    'conversational': 'Use a natural conversational tone. Explain reasoning briefly alongside code. Engage with the developer\'s questions.',
+    'detailed-structured': 'Match this developer\'s structured communication: use headers for sections, numbered lists for steps, and acknowledge provided context before responding.',
+    'mixed': 'Adapt response detail to match the complexity of each request. Brief for simple tasks, detailed for complex ones.',
+  },
+  decision_speed: {
+    'fast-intuitive': 'Present a single strong recommendation with brief justification. Skip lengthy comparisons unless asked.',
+    'deliberate-informed': 'Present options in a structured comparison table with pros/cons. Let the developer make the final call.',
+    'research-first': 'Include links to docs, GitHub repos, or benchmarks when recommending tools. Support the developer\'s research process.',
+    'delegator': 'Make clear recommendations with confidence. Explain your reasoning briefly, but own the suggestion.',
+  },
+  explanation_depth: {
+    'code-only': 'Prioritize code output. Add comments inline rather than prose explanations. Skip walkthroughs unless asked.',
+    'concise': 'Pair code with a brief explanation (1-2 sentences) of the approach. Keep prose minimal.',
+    'detailed': 'Explain the approach, key trade-offs, and code structure alongside the implementation. Use headers to organize.',
+    'educational': 'Teach the underlying concepts and principles, not just the implementation. Relate new patterns to fundamentals.',
+  },
+  debugging_approach: {
+    'fix-first': 'Prioritize the fix. Show the corrected code first, then optionally explain what was wrong. Minimize diagnostic preamble.',
+    'diagnostic': 'Diagnose the root cause before presenting the fix. Explain what went wrong and why the fix addresses it.',
+    'hypothesis-driven': 'Engage with the developer\'s theories. Validate or refine their hypotheses before jumping to solutions.',
+    'collaborative': 'Walk through the debugging process step by step. Explain the investigation approach, not just the conclusion.',
+  },
+  ux_philosophy: {
+    'function-first': 'Focus on functionality and correctness. Keep UI minimal and functional. Skip design polish unless requested.',
+    'pragmatic': 'Build clean, usable interfaces without over-engineering. Apply basic design principles (spacing, alignment, contrast).',
+    'design-conscious': 'Invest in UX quality: thoughtful spacing, smooth transitions, responsive layouts. Treat design as a first-class concern.',
+    'backend-focused': 'Optimize for developer experience (clear APIs, good error messages, helpful CLI output) over visual design.',
+  },
+  vendor_philosophy: {
+    'pragmatic-fast': 'Suggest libraries quickly based on popularity and reliability. Don\'t over-analyze choices for non-critical dependencies.',
+    'conservative': 'Recommend well-established, widely-adopted tools with strong community support. Avoid bleeding-edge options.',
+    'thorough-evaluator': 'Compare alternatives with specific metrics (bundle size, GitHub stars, maintenance activity). Support informed decisions.',
+    'opinionated': 'Respect the developer\'s existing tool preferences. Ask before suggesting alternatives to their preferred stack.',
+  },
+  frustration_triggers: {
+    'scope-creep': 'Do exactly what is asked -- nothing more. Never add unrequested features, refactoring, or "improvements". Ask before expanding scope.',
+    'instruction-adherence': 'Follow instructions precisely. Re-read constraints before responding. If requirements conflict, flag the conflict rather than silently choosing.',
+    'verbosity': 'Be concise. Lead with code, follow with brief explanation only if needed. Avoid restating the problem or unnecessary context.',
+    'regression': 'Before modifying working code, verify the change is safe. Run existing tests mentally. Flag potential regression risks explicitly.',
+  },
+  learning_style: {
+    'self-directed': 'Point to relevant code sections and let the developer explore. Add signposts (file paths, function names) rather than full explanations.',
+    'guided': 'Explain concepts in context of the developer\'s codebase. Use their actual code as examples when teaching.',
+    'documentation-first': 'Link to official documentation and relevant sections. Structure explanations like reference material.',
+    'example-driven': 'Lead with working code examples. Show a minimal example first, then explain how to extend or modify it.',
+  },
+};
+
+export function isAmbiguousAnswer(dimension: string, value: string): boolean {
+  if (dimension === 'communication_style' && value === 'd') return true;
+  const question = PROFILING_QUESTIONS.find((q) => q.dimension === dimension);
+  if (!question) return false;
+  const option = question.options.find((o) => o.value === value);
+  if (!option) return false;
+  return option.rating === 'mixed';
+}
+
+export function generateClaudeInstruction(dimension: string, rating: string): string {
+  const dimInstructions = CLAUDE_INSTRUCTIONS[dimension];
+  if (dimInstructions && dimInstructions[rating]) {
+    return dimInstructions[rating]!;
+  }
+  return `Adapt to this developer's ${dimension.replace(/_/g, ' ')} preference: ${rating}.`;
+}

package/sdk/src/query/profile-sample.ts

@@ -0,0 +1,184 @@
+/**
+ * `profile-sample` — parity with `get-shit-done/bin/lib/profile-pipeline.cjs` `cmdProfileSample`.
+ */
+import { appendFileSync, mkdtempSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { GSDError, ErrorClassification } from '../errors.js';
+import { getScanSessionsRoot, scanProjectDir, readSessionIndex, getProjectName } from './profile-scan-sessions.js';
+import { isGenuineUserMessage, streamExtractMessages, truncateContent } from './profile-extract-messages.js';
+
+export type ProfileSampleResult = {
+  output_file: string;
+  projects_sampled: number;
+  messages_sampled: number;
+  per_project_cap: number;
+  message_char_limit: number;
+  skipped_context_dumps: number;
+  project_breakdown: Array<{ project: string; messages: number; sessions: number }>;
+};
+
+/**
+ * Port of `cmdProfileSample` — same JSON + JSONL file shape as `gsd-tools profile-sample`.
+ */
+export async function runProfileSample(
+  overridePath: string | null,
+  options: { limit: number; maxPerProject: number | null; maxChars: number },
+): Promise<ProfileSampleResult> {
+  const sessionsDir = getScanSessionsRoot(overridePath);
+  if (!sessionsDir) {
+    const searchedPath = overridePath || '~/.claude/projects';
+    throw new GSDError(
+      `No Claude Code sessions found at ${searchedPath}.${overridePath ? '' : ' Is Claude Code installed?'}`,
+      ErrorClassification.Validation,
+    );
+  }
+
+  const limit = options.limit || 150;
+  const maxChars = options.maxChars || 500;
+  const maxPerProject = options.maxPerProject;
+
+  let projectDirs: string[];
+  try {
+    projectDirs = readdirSync(sessionsDir).filter((entry) => {
+      const fullPath = join(sessionsDir, entry);
+      try {
+        return statSync(fullPath).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GSDError(`Cannot read sessions directory: ${msg}`, ErrorClassification.Validation);
+  }
+
+  if (projectDirs.length === 0) {
+    throw new GSDError('No project directories found in sessions directory.', ErrorClassification.Validation);
+  }
+
+  const projectMeta: Array<{
+    dirName: string;
+    projectPath: string;
+    sessions: ReturnType<typeof scanProjectDir>;
+    projectName: string;
+    lastActive: Date;
+  }> = [];
+
+  for (const dirName of projectDirs) {
+    const projectPath = join(sessionsDir, dirName);
+    const sessions = scanProjectDir(projectPath);
+    if (sessions.length === 0) continue;
+    const indexData = readSessionIndex(projectPath);
+    const projectName = getProjectName(dirName, indexData);
+    const lastActive = sessions[0]!.modified;
+    projectMeta.push({ dirName, projectPath, sessions, projectName, lastActive });
+  }
+
+  projectMeta.sort((a, b) => b.lastActive.getTime() - a.lastActive.getTime());
+
+  const projectCount = projectMeta.length;
+  if (projectCount === 0) {
+    throw new GSDError('No projects with sessions found.', ErrorClassification.Validation);
+  }
+
+  const perProjectCap = maxPerProject || Math.max(5, Math.floor(limit / projectCount));
+
+  const recencyThreshold = Date.now() - 30 * 24 * 60 * 60 * 1000;
+  const allMessages: Array<{
+    sessionId: string;
+    projectName: string;
+    projectPath: string | null;
+    timestamp: string | number | null;
+    content: string;
+  }> = [];
+  let skippedContextDumps = 0;
+  const projectBreakdown: Array<{ project: string; messages: number; sessions: number }> = [];
+
+  for (const proj of projectMeta) {
+    if (allMessages.length >= limit) break;
+
+    const cappedSessions = proj.sessions.slice(0, perProjectCap);
+
+    let projectMessages = 0;
+    let projectSessionsUsed = 0;
+
+    for (const session of cappedSessions) {
+      if (allMessages.length >= limit) break;
+
+      const isRecent = session.modified.getTime() >= recencyThreshold;
+      const perSessionMax = isRecent ? 10 : 3;
+
+      const remaining = Math.min(perSessionMax, limit - allMessages.length);
+
+      try {
+        const msgs = await streamExtractMessages(session.filePath, isGenuineUserMessage, remaining);
+        let sessionUsed = false;
+
+        for (const msg of msgs) {
+          if (allMessages.length >= limit) break;
+
+          const content = msg.content || '';
+          if (content.startsWith('This session is being continued')) {
+            skippedContextDumps++;
+            continue;
+          }
+
+          const lines = content.split('\n').filter((l) => l.trim().length > 0);
+          if (lines.length > 3) {
+            const logPattern = /^\[?(DEBUG|INFO|WARN|ERROR|LOG)\]?/i;
+            const timestampPattern = /^\d{4}-\d{2}-\d{2}/;
+            const logLines = lines.filter(
+              (l) => logPattern.test(l.trim()) || timestampPattern.test(l.trim()),
+            );
+            if (logLines.length / lines.length > 0.8) {
+              skippedContextDumps++;
+              continue;
+            }
+          }
+
+          const truncated = truncateContent(content, maxChars);
+
+          allMessages.push({
+            sessionId: msg.sessionId,
+            projectName: proj.projectName,
+            projectPath: msg.projectPath,
+            timestamp: msg.timestamp,
+            content: truncated,
+          });
+
+          projectMessages++;
+          sessionUsed = true;
+        }
+        if (sessionUsed) projectSessionsUsed++;
+      } catch {
+        continue;
+      }
+    }
+
+    if (projectMessages > 0) {
+      projectBreakdown.push({
+        project: proj.projectName,
+        messages: projectMessages,
+        sessions: projectSessionsUsed,
+      });
+    }
+  }
+
+  const tmpDir = mkdtempSync(join(tmpdir(), 'gsd-profile-'));
+  const outputPath = join(tmpDir, 'profile-sample.jsonl');
+  for (const msg of allMessages) {
+    appendFileSync(outputPath, JSON.stringify(msg) + '\n');
+  }
+
+  return {
+    output_file: outputPath,
+    projects_sampled: projectBreakdown.length,
+    messages_sampled: allMessages.length,
+    per_project_cap: perProjectCap,
+    message_char_limit: maxChars,
+    skipped_context_dumps: skippedContextDumps,
+    project_breakdown: projectBreakdown,
+  };
+}

package/sdk/src/query/profile-scan-sessions.ts

@@ -0,0 +1,174 @@
+/**
+ * Session scan — parity with `get-shit-done/bin/lib/profile-pipeline.cjs` `cmdScanSessions`.
+ * Used by `scanSessions` query handler so SDK JSON matches `gsd-tools.cjs scan-sessions --json`.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { homedir } from 'node:os';
+
+/** One project entry in the JSON array emitted by `scan-sessions --json`. */
+export type ScanSessionsProject = {
+  name: string;
+  directory: string;
+  sessionCount: number;
+  totalSize: number;
+  totalSizeHuman: string;
+  lastActive: string;
+  dateRange: { first: string; last: string };
+  sessions?: Array<{
+    sessionId: string;
+    size: number;
+    sizeHuman: string;
+    /** Full ISO-8601, same as CJS `scan-sessions --json --verbose`. */
+    modified: string;
+    summary?: string;
+    messageCount?: number;
+    created?: string;
+  }>;
+};
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1073741824) return `${(bytes / 1048576).toFixed(1)} MB`;
+  return `${(bytes / 1073741824).toFixed(1)} GB`;
+}
+
+/** Same as CJS `scanProjectDir` in profile-pipeline.cjs (sessions sorted newest-first). */
+export function scanProjectDir(projectDirPath: string): Array<{
+  sessionId: string;
+  filePath: string;
+  size: number;
+  modified: Date;
+}> {
+  const entries = readdirSync(projectDirPath);
+  const sessions: Array<{ sessionId: string; filePath: string; size: number; modified: Date }> = [];
+
+  for (const entry of entries) {
+    if (!entry.endsWith('.jsonl')) continue;
+    const sessionId = entry.replace('.jsonl', '');
+    const filePath = join(projectDirPath, entry);
+    const stat = statSync(filePath);
+
+    sessions.push({
+      sessionId,
+      filePath,
+      size: stat.size,
+      modified: stat.mtime,
+    });
+  }
+
+  sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+  return sessions;
+}
+
+export function readSessionIndex(projectDirPath: string): {
+  originalPath: string | null;
+  entries: Map<string, { sessionId?: string; summary?: string; messageCount?: number; created?: string }>;
+} {
+  try {
+    const indexPath = join(projectDirPath, 'sessions-index.json');
+    const raw = readFileSync(indexPath, 'utf-8');
+    const parsed = JSON.parse(raw) as { entries?: unknown[]; originalPath?: string | null };
+    const entries = new Map<string, { sessionId?: string; summary?: string; messageCount?: number; created?: string }>();
+    for (const entry of parsed.entries || []) {
+      const e = entry as { sessionId?: string; summary?: string; messageCount?: number; created?: string };
+      if (e.sessionId) {
+        entries.set(e.sessionId, e);
+      }
+    }
+    return { originalPath: parsed.originalPath ?? null, entries };
+  } catch {
+    return { originalPath: null, entries: new Map() };
+  }
+}
+
+export function getProjectName(projectDirName: string, indexData: ReturnType<typeof readSessionIndex>): string {
+  if (indexData.originalPath) {
+    return basename(indexData.originalPath);
+  }
+  return projectDirName;
+}
+
+/** Same resolution as CJS `getSessionsDir` in profile-pipeline.cjs. */
+export function getScanSessionsRoot(overridePath: string | null): string | null {
+  const dir = overridePath || join(homedir(), '.claude', 'projects');
+  if (!existsSync(dir)) return null;
+  return dir;
+}
+
+/**
+ * Build the same project array as CJS `cmdScanSessions` (stdout JSON when `--json`).
+ */
+export function buildScanSessionsProjects(
+  overridePath: string | null,
+  options: { verbose: boolean },
+): ScanSessionsProject[] {
+  const sessionsDir = getScanSessionsRoot(overridePath);
+  if (!sessionsDir) {
+    return [];
+  }
+
+  let projectDirs: string[];
+  try {
+    projectDirs = readdirSync(sessionsDir).filter((entry) => {
+      const fullPath = join(sessionsDir, entry);
+      try {
+        return statSync(fullPath).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+
+  const projects: ScanSessionsProject[] = [];
+
+  for (const dirName of projectDirs) {
+    const projectPath = join(sessionsDir, dirName);
+    const sessions = scanProjectDir(projectPath);
+    if (sessions.length === 0) continue;
+
+    const indexData = readSessionIndex(projectPath);
+    const projectName = getProjectName(dirName, indexData);
+
+    const totalSize = sessions.reduce((sum, s) => sum + s.size, 0);
+    const lastActive = sessions[0].modified.toISOString();
+    const oldest = sessions[sessions.length - 1].modified.toISOString();
+    const newest = sessions[0].modified.toISOString();
+
+    const project: ScanSessionsProject = {
+      name: projectName,
+      directory: dirName,
+      sessionCount: sessions.length,
+      totalSize,
+      totalSizeHuman: formatBytes(totalSize),
+      lastActive: lastActive.replace('T', ' ').substring(0, 19),
+      dateRange: { first: oldest, last: newest },
+    };
+
+    if (options.verbose) {
+      project.sessions = sessions.map((s) => {
+        const indexed = indexData.entries.get(s.sessionId);
+        const session: NonNullable<ScanSessionsProject['sessions']>[number] = {
+          sessionId: s.sessionId,
+          size: s.size,
+          sizeHuman: formatBytes(s.size),
+          modified: s.modified.toISOString(),
+        };
+        if (indexed) {
+          if (indexed.summary) session.summary = indexed.summary;
+          if (indexed.messageCount !== undefined) session.messageCount = indexed.messageCount;
+          if (indexed.created) session.created = indexed.created;
+        }
+        return session;
+      });
+    }
+
+    projects.push(project);
+  }
+
+  projects.sort((a, b) => b.dateRange.last.localeCompare(a.dateRange.last));
+  return projects;
+}

package/sdk/src/query/profile.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Tests for profile / learnings query handlers (filesystem writes use temp dirs).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, writeFile, mkdir, rm, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { generateDevPreferences, writeProfile } from './profile-output.js';
+import { learningsCopy } from './profile.js';
+
+describe('writeProfile', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'gsd-profile-'));
+    await mkdir(join(tmpDir, '.planning'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('writes USER-PROFILE.md from --input JSON (CJS template + dimensions shape)', async () => {
+    const analysisPath = join(tmpDir, 'analysis.json');
+    const outPath = join(tmpDir, '.planning', 'USER-PROFILE.md');
+    await writeFile(
+      analysisPath,
+      JSON.stringify({
+        profile_version: '1.0',
+        data_source: 'test',
+        dimensions: {
+          communication_style: {
+            rating: 'terse-direct',
+            confidence: 'HIGH',
+            claude_instruction: 'Keep it short.',
+            summary: 'Test summary.',
+            evidence: [],
+          },
+        },
+      }),
+      'utf-8',
+    );
+    const result = await writeProfile(['--input', analysisPath, '--output', outPath], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.profile_path).toBe(outPath);
+    expect(data.dimensions_scored).toBe(1);
+    const md = await readFile(outPath, 'utf-8');
+    expect(md).toContain('Developer Profile');
+    expect(md).toMatch(/Communication Style/i);
+  });
+});
+
+describe('generateDevPreferences', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'gsd-dev-preferences-'));
+    await mkdir(join(tmpDir, '.planning'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('writes to runtime-global skills dir by default', async () => {
+    const analysisPath = join(tmpDir, 'analysis.json');
+    const codexHome = join(tmpDir, 'codex-home');
+    await writeFile(
+      analysisPath,
+      JSON.stringify({
+        data_source: 'test',
+        dimensions: {
+          communication_style: { rating: 'terse', confidence: 'HIGH', claude_instruction: 'Keep it short.' },
+        },
+      }),
+      'utf-8',
+    );
+    await writeFile(join(tmpDir, '.planning', 'config.json'), JSON.stringify({ runtime: 'codex' }), 'utf-8');
+
+    const prevCodexHome = process.env.CODEX_HOME;
+    process.env.CODEX_HOME = codexHome;
+    try {
+      const result = await generateDevPreferences(['--analysis', analysisPath], tmpDir);
+      const data = result.data as Record<string, unknown>;
+      const expectedPath = join(codexHome, 'skills', 'gsd-dev-preferences', 'SKILL.md');
+      expect(data.command_path).toBe(expectedPath);
+      const md = await readFile(expectedPath, 'utf-8');
+      expect(md).toContain('Behavioral Directives');
+    } finally {
+      if (prevCodexHome === undefined) delete process.env.CODEX_HOME;
+      else process.env.CODEX_HOME = prevCodexHome;
+    }
+  });
+
+  it('requires --output when runtime has no skills dir', async () => {
+    const analysisPath = join(tmpDir, 'analysis.json');
+    await writeFile(
+      analysisPath,
+      JSON.stringify({
+        data_source: 'test',
+        dimensions: {
+          communication_style: { rating: 'terse', confidence: 'HIGH', claude_instruction: 'Keep it short.' },
+        },
+      }),
+      'utf-8',
+    );
+    await writeFile(join(tmpDir, '.planning', 'config.json'), JSON.stringify({ runtime: 'cline' }), 'utf-8');
+
+    await expect(generateDevPreferences(['--analysis', analysisPath], tmpDir)).rejects.toThrow(
+      'Runtime "cline" does not use a skills directory; pass --output to choose a path explicitly.',
+    );
+  });
+});
+
+describe('learningsCopy', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'gsd-learn-'));
+    await mkdir(join(tmpDir, '.planning'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns zero counts when LEARNINGS.md is missing (matches learnings.cjs)', async () => {
+    const result = await learningsCopy([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.total).toBe(0);
+    expect(data.created).toBe(0);
+    expect(data.skipped).toBe(0);
+  });
+});