@vanshbhardwaj/worklog 1.0.0

package/src/tests/cli/cli-productivity.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+interface CLIResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+function runCLI(args: string[], cwd: string): CLIResult {
+  const cliPath = path.resolve(process.cwd(), 'dist', 'index.js');
+  try {
+    const stdout = execSync(`node ${cliPath} ${args.join(' ')}`, {
+      cwd,
+      stdio: 'pipe',
+    });
+    return {
+      stdout: stdout.toString(),
+      stderr: '',
+      exitCode: 0,
+    };
+  } catch (error: any) {
+    return {
+      stdout: error.stdout ? error.stdout.toString() : '',
+      stderr: error.stderr ? error.stderr.toString() : '',
+      exitCode: error.status !== undefined ? error.status : 1,
+    };
+  }
+}
+
+function sanitizeStdout(stdout: string): string {
+  return stdout
+    .replace(/(Created|Updated):\s+.*/g, (_, label) => `${label}:   [DATE]`)
+    .replace(/\b[A-Za-z]{3}\s+\d{1,2}\b/g, '[DATE]')
+    .replace(/\d{4}-\d{2}-\d{2}/g, '[DATE]')
+    .replace(/\d{1,2}:\d{2}\s+(AM|PM)/g, '[TIME]');
+}
+
+describe('WorkLog CLI Productivity Commands', () => {
+  const tempProdDir = path.join(process.cwd(), 'src', 'tests', 'temp-prod-test');
+
+  beforeAll(() => {
+    if (fs.existsSync(tempProdDir)) {
+      fs.rmSync(tempProdDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempProdDir, { recursive: true });
+    runCLI(['init'], tempProdDir);
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(tempProdDir)) {
+      fs.rmSync(tempProdDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should run all commands successfully on empty repository', () => {
+    expect(runCLI(['today'], tempProdDir).stdout.trim()).toBe('No work units logged today.');
+    expect(runCLI(['week'], tempProdDir).stdout.trim()).toBe(
+      'No work units logged in the past 7 days.',
+    );
+    expect(runCLI(['dashboard'], tempProdDir).exitCode).toBe(0);
+    expect(runCLI(['continue'], tempProdDir).stdout.trim()).toBe('No unfinished work units found.');
+    expect(runCLI(['stats'], tempProdDir).exitCode).toBe(0);
+    expect(runCLI(['export'], tempProdDir).stdout.trim()).toBe('No work units found.');
+  });
+
+  it('should support Unicode characters and long text', () => {
+    const unicodeTitle = 'Unicode test ☕ 汉字';
+    const res = runCLI(
+      ['add', '--title', `"${unicodeTitle}"`, '--type', 'idea', '--status', 'planned'],
+      tempProdDir,
+    );
+    expect(res.exitCode).toBe(0);
+
+    const showRes = runCLI(['show', '1', '--json'], tempProdDir);
+    const unit = JSON.parse(showRes.stdout);
+    expect(unit.title).toBe(unicodeTitle);
+  });
+
+  it('should perform advanced search by tags and status', () => {
+    runCLI(
+      [
+        'add',
+        '--title',
+        '"Tags task"',
+        '--type',
+        'bug',
+        '--status',
+        'blocked',
+        '--tags',
+        'frontend,issue-9',
+        '--module',
+        'billing',
+      ],
+      tempProdDir,
+    );
+
+    // Search tag
+    const searchTag = runCLI(['search', '--tag', 'frontend', '--json'], tempProdDir);
+    const results = JSON.parse(searchTag.stdout);
+    expect(results.length).toBe(1);
+    expect(results[0].title).toBe('Tags task');
+
+    // Combine FTS text + tag filter
+    const searchCombined = runCLI(['search', 'Tags', '--status', 'blocked', '--json'], tempProdDir);
+    const results2 = JSON.parse(searchCombined.stdout);
+    expect(results2.length).toBe(1);
+  });
+
+  it('should run continue command and resume last unfinished unit', () => {
+    // We have unit #1 (Planned) and unit #2 (Blocked)
+    // Run continue (will choose unit 2 since it was updated last)
+    const res = runCLI(['continue', '--json'], tempProdDir);
+    expect(res.exitCode).toBe(0);
+    const data = JSON.parse(res.stdout);
+    expect(data.id).toBe(2);
+    expect(data.status).toBe('In Progress');
+  });
+
+  it('should display dashboard (snapshot)', () => {
+    const res = runCLI(['dashboard'], tempProdDir);
+    expect(res.exitCode).toBe(0);
+    expect(sanitizeStdout(res.stdout)).toMatchSnapshot();
+  });
+
+  it('should display stats summary (snapshot)', () => {
+    const res = runCLI(['stats'], tempProdDir);
+    expect(res.exitCode).toBe(0);
+    expect(sanitizeStdout(res.stdout)).toMatchSnapshot();
+  });
+
+  it('should export all to markdown and JSON file', () => {
+    const mdPath = path.join(tempProdDir, 'export.md');
+    const resMd = runCLI(
+      ['export', '--format', 'markdown', '--output', `"${mdPath}"`],
+      tempProdDir,
+    );
+    expect(resMd.exitCode).toBe(0);
+    expect(fs.existsSync(mdPath)).toBe(true);
+    expect(fs.readFileSync(mdPath, 'utf8')).toContain('# WorkLog Export');
+
+    const singleJSON = runCLI(['export', '--id', '1', '--format', 'json'], tempProdDir);
+    expect(singleJSON.exitCode).toBe(0);
+    const data = JSON.parse(singleJSON.stdout);
+    expect(data.id).toBe(1);
+  });
+
+  it('should throw exit code 1 on invalid export path', () => {
+    const res = runCLI(
+      ['export', '--format', 'markdown', '--output', '"/non/existent/path/export.md"'],
+      tempProdDir,
+    );
+    expect(res.exitCode).toBe(1);
+    expect(res.stderr).toContain('Failed to write to file');
+  });
+
+  it('should handle database corruption/unexpected failures gracefully with exit code 2', () => {
+    const dbPath = path.join(tempProdDir, '.worklog', 'worklog.db');
+    fs.writeFileSync(dbPath, 'completely corrupted database text', 'utf8');
+
+    const res = runCLI(['list'], tempProdDir);
+    expect(res.exitCode).toBe(2);
+    expect(res.stderr).toContain('Unexpected Error');
+  });
+});

package/src/tests/cli/cli.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+interface CLIResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+function runCLI(args: string[], cwd: string): CLIResult {
+  const cliPath = path.resolve(process.cwd(), 'dist', 'index.js');
+  try {
+    const stdout = execSync(`node ${cliPath} ${args.join(' ')}`, {
+      cwd,
+      stdio: 'pipe',
+    });
+    return {
+      stdout: stdout.toString(),
+      stderr: '',
+      exitCode: 0,
+    };
+  } catch (error: any) {
+    return {
+      stdout: error.stdout ? error.stdout.toString() : '',
+      stderr: error.stderr ? error.stderr.toString() : '',
+      exitCode: error.status !== undefined ? error.status : 1,
+    };
+  }
+}
+
+function sanitizeStdout(stdout: string): string {
+  return stdout
+    .replace(/(Created|Updated):\s+.*/g, (_, label) => `${label}:   [DATE]`)
+    .replace(/\b[A-Za-z]{3}\s+\d{1,2}\b/g, '[DATE]');
+}
+
+describe('WorkLog CLI Integration', () => {
+  const tempCLIDir = path.join(process.cwd(), 'src', 'tests', 'temp-cli-test');
+
+  beforeAll(() => {
+    if (fs.existsSync(tempCLIDir)) {
+      fs.rmSync(tempCLIDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempCLIDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(tempCLIDir)) {
+      fs.rmSync(tempCLIDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should fail when running list outside a initialized repository', () => {
+    const res = runCLI(['list'], tempCLIDir);
+    expect(res.exitCode).toBe(1);
+    expect(res.stderr).toContain('Not a WorkLog repository');
+  });
+
+  it('should initialize a empty repository successfully', () => {
+    const res = runCLI(['init'], tempCLIDir);
+    expect(res.exitCode).toBe(0);
+    expect(res.stdout).toContain('Initialized empty WorkLog repository');
+
+    // Check files are created
+    expect(fs.existsSync(path.join(tempCLIDir, '.worklog'))).toBe(true);
+    expect(fs.existsSync(path.join(tempCLIDir, '.worklog', 'config.json'))).toBe(true);
+    expect(fs.existsSync(path.join(tempCLIDir, '.worklog', 'worklog.db'))).toBe(true);
+  });
+
+  it('should list empty results when database is empty', () => {
+    const res = runCLI(['list'], tempCLIDir);
+    expect(res.exitCode).toBe(0);
+    expect(res.stdout.trim()).toBe('No work units found.');
+
+    const resJson = runCLI(['list', '--json'], tempCLIDir);
+    expect(resJson.exitCode).toBe(0);
+    expect(JSON.parse(resJson.stdout)).toEqual([]);
+  });
+
+  it('should create a work unit with flags', () => {
+    const res = runCLI(
+      [
+        'add',
+        '--title',
+        '"First Task"',
+        '--type',
+        'feature',
+        '--status',
+        'planned',
+        '--module',
+        'auth',
+        '--tags',
+        'login,security',
+      ],
+      tempCLIDir,
+    );
+    expect(res.exitCode).toBe(0);
+    expect(res.stdout).toContain('Created work unit #1: First Task');
+  });
+
+  it('should support json flag on add', () => {
+    const res = runCLI(
+      ['add', '--title', '"Second Task"', '--type', 'bug', '--status', 'in-progress', '--json'],
+      tempCLIDir,
+    );
+    expect(res.exitCode).toBe(0);
+    const data = JSON.parse(res.stdout);
+    expect(data.id).toBe(2);
+    expect(data.title).toBe('Second Task');
+    expect(data.type).toBe('Bug');
+    expect(data.status).toBe('In Progress');
+  });
+
+  it('should output validation errors cleanly and exit with 1', () => {
+    // Title too long
+    const longTitle = 'a'.repeat(250);
+    const res = runCLI(['add', '--title', `"${longTitle}"`], tempCLIDir);
+    expect(res.exitCode).toBe(1);
+    expect(res.stderr).toContain('Title cannot exceed 200 characters');
+  });
+
+  it('should list work units in a beautiful table format (snapshot)', () => {
+    const res = runCLI(['list'], tempCLIDir);
+    expect(res.exitCode).toBe(0);
+    // Snapshot checking of the table representation
+    expect(sanitizeStdout(res.stdout)).toMatchSnapshot();
+  });
+
+  it('should list work units in JSON format', () => {
+    const res = runCLI(['list', '--json'], tempCLIDir);
+    expect(res.exitCode).toBe(0);
+    const data = JSON.parse(res.stdout);
+    expect(data.length).toBe(2);
+    expect(data[0].id).toBe(2);
+    expect(data[1].id).toBe(1);
+  });
+
+  it('should show card details for a specific unit (snapshot)', () => {
+    const res = runCLI(['show', '1'], tempCLIDir);
+    expect(res.exitCode).toBe(0);
+    expect(sanitizeStdout(res.stdout)).toMatchSnapshot();
+  });
+
+  it('should show JSON details for a specific unit', () => {
+    const res = runCLI(['show', '2', '--json'], tempCLIDir);
+    expect(res.exitCode).toBe(0);
+    const data = JSON.parse(res.stdout);
+    expect(data.id).toBe(2);
+    expect(data.title).toBe('Second Task');
+  });
+
+  it('should show error and exit with 1 if unit does not exist', () => {
+    const res = runCLI(['show', '999'], tempCLIDir);
+    expect(res.exitCode).toBe(1);
+    expect(res.stderr).toContain('Work unit #999 not found');
+  });
+
+  it('should handle unknown command routing', () => {
+    const res = runCLI(['hello-unknown'], tempCLIDir);
+    expect(res.exitCode).toBe(1);
+    expect(res.stderr).toContain('Unknown command: hello-unknown');
+  });
+
+  it('should cancel add if title is missing in non-TTY mode', () => {
+    // Since title is missing and stdin is closed in runCLI subprocess, it should exit with cancel code 1
+    const res = runCLI(['add'], tempCLIDir);
+    expect(res.exitCode).toBe(1);
+  });
+});

package/src/tests/core/config.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { loadConfig, saveConfig, initConfig } from '../../core/config.js';
+import { ConfigError } from '../../errors/index.js';
+
+describe('config', () => {
+  const tempTestDir = path.join(process.cwd(), 'src', 'tests', 'temp-config-test');
+
+  beforeAll(() => {
+    if (fs.existsSync(tempTestDir)) {
+      fs.rmSync(tempTestDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempTestDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(tempTestDir)) {
+      fs.rmSync(tempTestDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should initialize config with default values', () => {
+    const config = initConfig(tempTestDir, 'test-project');
+    expect(config.projectName).toBe('test-project');
+    expect(config.schemaVersion).toBe(1);
+    expect(config.createdAt).toBeDefined();
+
+    // Verify it wrote the file
+    const fileExists = fs.existsSync(path.join(tempTestDir, '.worklog', 'config.json'));
+    expect(fileExists).toBe(true);
+  });
+
+  it('should load config that has been saved', () => {
+    const loaded = loadConfig(tempTestDir);
+    expect(loaded.projectName).toBe('test-project');
+  });
+
+  it('should throw ConfigError if config is missing', () => {
+    const emptyDir = path.join(tempTestDir, 'empty');
+    fs.mkdirSync(emptyDir, { recursive: true });
+    expect(() => loadConfig(emptyDir)).toThrow(ConfigError);
+  });
+
+  it('should throw ConfigError if config format is invalid', () => {
+    const invalidDir = path.join(tempTestDir, 'invalid');
+    const dotWorklog = path.join(invalidDir, '.worklog');
+    fs.mkdirSync(dotWorklog, { recursive: true });
+    fs.writeFileSync(path.join(dotWorklog, 'config.json'), '{"invalid": "json"}', 'utf8');
+
+    expect(() => loadConfig(invalidDir)).toThrow(ConfigError);
+  });
+});

package/src/tests/core/discovery.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { findWorkspaceRoot, getWorkspaceRoot } from '../../core/discovery.js';
+import { NotInitializedError } from '../../errors/index.js';
+
+describe('discovery', () => {
+  const tempTestDir = path.join(process.cwd(), 'src', 'tests', 'temp-discovery-test');
+
+  beforeAll(() => {
+    if (fs.existsSync(tempTestDir)) {
+      fs.rmSync(tempTestDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempTestDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(tempTestDir)) {
+      fs.rmSync(tempTestDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should return null when .worklog is not present in parent chain', () => {
+    const subDir = path.join(tempTestDir, 'a', 'b', 'c');
+    fs.mkdirSync(subDir, { recursive: true });
+    expect(findWorkspaceRoot(subDir)).toBeNull();
+  });
+
+  it('should find the .worklog root when it exists in a parent directory', () => {
+    const worklogRoot = path.join(tempTestDir, 'project-root');
+    const dotWorklog = path.join(worklogRoot, '.worklog');
+    const subDir = path.join(worklogRoot, 'src', 'core');
+
+    fs.mkdirSync(dotWorklog, { recursive: true });
+    fs.mkdirSync(subDir, { recursive: true });
+
+    const discovered = findWorkspaceRoot(subDir);
+    expect(discovered).toBe(worklogRoot);
+  });
+
+  it('should throw NotInitializedError if not initialized', () => {
+    const nonExistentDir = path.join(tempTestDir, 'non-existent');
+    fs.mkdirSync(nonExistentDir, { recursive: true });
+    expect(() => getWorkspaceRoot(nonExistentDir)).toThrow(NotInitializedError);
+  });
+});

package/src/tests/database/migrations.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+import { runMigrations } from '../../database/migrations.js';
+
+describe('migrations', () => {
+  const tempTestDir = path.join(process.cwd(), 'src', 'tests', 'temp-migrations-test');
+  let db: Database.Database;
+
+  beforeAll(() => {
+    if (fs.existsSync(tempTestDir)) {
+      fs.rmSync(tempTestDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempTestDir, { recursive: true });
+
+    const dbPath = path.join(tempTestDir, 'test.db');
+    db = new Database(dbPath);
+  });
+
+  afterAll(() => {
+    if (db) {
+      db.close();
+    }
+    if (fs.existsSync(tempTestDir)) {
+      fs.rmSync(tempTestDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should run migrations successfully and create tables', () => {
+    runMigrations(db);
+
+    // Verify migration tracking table has records for both files
+    const migrations = db.prepare('SELECT version FROM schema_migrations ORDER BY version ASC').all();
+    expect(migrations.length).toBe(2);
+    expect(migrations[0]).toEqual({ version: '001_initial.sql' });
+    expect(migrations[1]).toEqual({ version: '002_relational_tables.sql' });
+
+    // Verify work_units table exists and we can insert a row
+    const insertStmt = db.prepare(`
+      INSERT INTO work_units (title, type, status, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    const info = insertStmt.run(
+      'Test Work Unit',
+      'Feature',
+      'In Progress',
+      new Date().toISOString(),
+      new Date().toISOString(),
+    );
+    expect(info.changes).toBe(1);
+    const workUnitId = info.lastInsertRowid;
+
+    // Verify work_unit_tags table exists and works
+    const tagInsert = db.prepare('INSERT INTO work_unit_tags (work_unit_id, tag) VALUES (?, ?)');
+    const tagInfo = tagInsert.run(workUnitId, 'cli');
+    expect(tagInfo.changes).toBe(1);
+
+    // Verify work_unit_relations table exists and works
+    const relInsert = db.prepare('INSERT INTO work_unit_relations (work_unit_id, related_work_unit_id) VALUES (?, ?)');
+    const relInfo = relInsert.run(workUnitId, workUnitId); // self-referencing relationship for testing
+    expect(relInfo.changes).toBe(1);
+
+    // Verify FTS table matches and can be queried
+    const ftsResults = db.prepare(`
+      SELECT rowid, title FROM work_units_fts WHERE work_units_fts MATCH 'Test'
+    `).all();
+    expect(ftsResults.length).toBe(1);
+    expect((ftsResults[0] as any).title).toBe('Test Work Unit');
+  });
+
+  it('should not run migrations twice if already applied', () => {
+    expect(() => runMigrations(db)).not.toThrow();
+  });
+});