Skip to content

peterfei/ai-agent-team / .claude/skills/thread-manager

thread-manager

Flagged

FileKindSize
.claude/.threads/current-context.mdmarkdown648 B
.gitignoreother76 B
.npmignoreother138 B
CHANGELOG.mdmarkdown1.1 KB
README.mdmarkdown4.7 KB
SKILL.mdskill md1.7 KB
USAGE_GUIDE.mdmarkdown6.7 KB
docs/clt-aliases.mdmarkdown2.2 KB
find-module.jsscript166 B
jest.config.jsscript1.1 KB
models/Xenova/all-MiniLM-L6-v2/config.jsonconfig650 B
models/Xenova/all-MiniLM-L6-v2/onnx/model_quantized.onnxother21.9 MB
models/Xenova/all-MiniLM-L6-v2/special_tokens_map.jsonconfig125 B
models/Xenova/all-MiniLM-L6-v2/tokenizer.jsonconfig695.0 KB
models/Xenova/all-MiniLM-L6-v2/tokenizer_config.jsonconfig366 B
package-lock.jsonmanifest406.8 KB
package.jsonmanifest1.1 KB
scripts/download-model.jsscript1.7 KB
scripts/migrate-embeddings.tsscript3.4 KB
src/core/embedding-service.tsscript4.3 KB
src/core/thread-manager.tsscript14.3 KB
src/core/vector-search-engine.tsscript1.2 KB
src/core/vector-utils.tsscript1.0 KB
src/database/db.tsscript4.5 KB
src/database/file-changes-dao.tsscript2.8 KB
src/database/index.tsscript121 B
src/database/messages-dao.tsscript5.1 KB
src/database/threads-dao.tsscript6.4 KB
src/git/git-integration.tsscript5.6 KB
src/index.tsscript257 B
src/server.tsscript6.1 KB
src/tools/add-message.tsscript1.5 KB
src/tools/create-thread.tsscript1.3 KB
src/tools/delete-thread.tsscript925 B
src/tools/get-current-thread.tsscript2.6 KB
src/tools/get-thread.tsscript1.2 KB
src/tools/list-threads.tsscript1.2 KB
src/tools/search-messages.tsscript4.4 KB
src/tools/switch-thread.tsscript1.4 KB
src/tools/track-file-change.tsscript1.7 KB
src/tools/update-thread.tsscript1.2 KB
src/types/index.tsscript2.6 KB
test-add-message.jsscript2.3 KB
test-output-format.jsscript546 B
tests/integration/file-tracker.test.tsscript3.3 KB
tests/integration/mcp-tools.test.tsscript5.4 KB
tests/integration/search-messages.test.tsscript5.8 KB
tests/unit/__mocks__/embedding-service.tsscript1.3 KB
tests/unit/database.test.tsscript1.6 KB
tests/unit/file-changes-dao.test.tsscript3.6 KB
tests/unit/git-integration.test.tsscript4.9 KB
tests/unit/messages-dao.test.tsscript3.9 KB
tests/unit/thread-manager.test.tsscript9.2 KB
tests/unit/threads-dao.test.tsscript6.0 KB
tests/unit/vector-search.test.tsscript3.7 KB
tsconfig.jsonconfig464 B

tests/unit/threads-dao.test.ts

View on GitHub
import { DatabaseManager, ThreadsDAO } from '../../src/database';
import { Thread } from '../../src/types';
import path from 'path';
import fs from 'fs-extra';
import { v4 as uuidv4 } from 'uuid';

describe('ThreadsDAO', () => {
  const testDir = path.join(__dirname, '../../tmp-test-db');
  let dbPath: string;
  let dbManager: DatabaseManager;
  let threadsDAO: ThreadsDAO;

  beforeAll(() => {
    fs.ensureDirSync(testDir);
  });

  afterAll(() => {
    // fs.removeSync(testDir); // Removed to avoid ENOTEMPTY error across test suites
  });

  beforeEach(() => {
    dbPath = path.join(testDir, `test-threads-${uuidv4()}.db`);
    dbManager = new DatabaseManager(dbPath);
    dbManager.init();
    threadsDAO = new ThreadsDAO(dbManager);
  });

  afterEach(() => {
    dbManager.close();
    if (fs.existsSync(dbPath)) {
      fs.unlinkSync(dbPath);
    }
  });

  it('should create a new thread', () => {
    const thread = threadsDAO.create({
      title: 'Test Thread',
      description: 'This is a test thread',
      isActive: true,
      metadata: { tags: ['tag1', 'tag2'] }
    });

    expect(thread).toBeDefined();
    expect(thread.title).toBe('Test Thread');
    expect(thread.isActive).toBe(true);
    expect(thread.metadata.tags).toEqual(['tag1', 'tag2']);

    const foundThread = threadsDAO.findById(thread.id);
    expect(foundThread).toEqual(thread);
  });

  it('should find a thread by ID', () => {
    const thread1 = threadsDAO.create({ title: 'Thread 1' });
    const found = threadsDAO.findById(thread1.id);
    expect(found).toEqual(thread1);
  });

  it('should return null if thread not found', () => {
    const found = threadsDAO.findById('non-existent-id');
    expect(found).toBeNull();
  });

  it('should find all threads', () => {
    threadsDAO.create({ title: 'Thread A', createdAt: new Date(Date.now() - 10000) });
    threadsDAO.create({ title: 'Thread B', createdAt: new Date(Date.now() - 20000) });
    const { threads, total } = threadsDAO.findAll();
    expect(total).toBe(2);
    expect(threads.length).toBe(2);
    // Default sort is by updatedAt DESC, so Thread A should be first (newer)
    expect(threads[0].title).toBe('Thread A');
  });

  it('should find all threads with sorting and pagination', () => {
    threadsDAO.create({ title: 'Thread 1', messageCount: 10, createdAt: new Date('2025-01-01') });
    threadsDAO.create({ title: 'Thread 2', messageCount: 5, createdAt: new Date('2025-01-02') });
    threadsDAO.create({ title: 'Thread 3', messageCount: 15, createdAt: new Date('2025-01-03') });

    let result = threadsDAO.findAll({ sortBy: 'messageCount', order: 'desc', limit: 2 });
    expect(result.total).toBe(3);
    expect(result.threads.length).toBe(2);
    expect(result.threads[0].title).toBe('Thread 3');
    expect(result.threads[1].title).toBe('Thread 1');

    result = threadsDAO.findAll({ sortBy: 'createdAt', order: 'asc', limit: 1, offset: 1 });
    expect(result.total).toBe(3);
    expect(result.threads.length).toBe(1);
    expect(result.threads[0].title).toBe('Thread 2');
  });

  it('should find all threads filtered by tags', () => {
    threadsDAO.create({ title: 'Thread A', metadata: { tags: ['frontend', 'bug'] } });
    threadsDAO.create({ title: 'Thread B', metadata: { tags: ['backend', 'feature'] } });
    threadsDAO.create({ title: 'Thread C', metadata: { tags: ['frontend', 'feature'] } });

    let result = threadsDAO.findAll({ tags: ['frontend'] });
    expect(result.total).toBe(2); // Should find Thread A and Thread C
    expect(result.threads.length).toBe(2);

    const frontendThreads = result.threads.filter(t => t.metadata.tags?.includes('frontend'));
    expect(frontendThreads.length).toBe(2); // Threads A and C

    result = threadsDAO.findAll({ tags: ['backend'] });
    expect(result.total).toBe(1);
    expect(result.threads[0].title).toBe('Thread B');
  });

  it('should update a thread', async () => {
    const thread = threadsDAO.create({ title: 'Original Title' });

    // Add a small delay to ensure updatedAt is strictly greater
    await new Promise(resolve => setTimeout(resolve, 10));

    const updatedThread = threadsDAO.update(thread.id, {
      title: 'Updated Title',
      description: 'Updated Description',
      metadata: { tags: ['newTag'] }
    });

    expect(updatedThread).toBeDefined();
    expect(updatedThread!.title).toBe('Updated Title');
    expect(updatedThread!.description).toBe('Updated Description');
    expect(updatedThread!.metadata.tags).toEqual(['newTag']);
    expect(updatedThread!.updatedAt.getTime()).toBeGreaterThan(thread.updatedAt.getTime());

    const foundThread = threadsDAO.findById(thread.id);
    expect(foundThread).toEqual(updatedThread);
  });

  it('should delete a thread', () => {
    const thread = threadsDAO.create({ title: 'Thread to Delete' });
    const deleted = threadsDAO.delete(thread.id);
    expect(deleted).toBe(true);

    const found = threadsDAO.findById(thread.id);
    expect(found).toBeNull();
  });

  it('should set a thread as active and deactivate others', () => {
    const thread1 = threadsDAO.create({ title: 'Thread 1', isActive: true });
    const thread2 = threadsDAO.create({ title: 'Thread 2', isActive: false });
    const thread3 = threadsDAO.create({ title: 'Thread 3', isActive: false });

    expect(threadsDAO.getActive()?.id).toBe(thread1.id);

    const activated = threadsDAO.setActive(thread2.id);
    expect(activated).toBe(true);

    const activeThread = threadsDAO.getActive();
    expect(activeThread?.id).toBe(thread2.id);

    // Verify thread1 is no longer active
    const thread1After = threadsDAO.findById(thread1.id);
    expect(thread1After?.isActive).toBe(false);
  });

  it('should get the active thread', () => {
    const thread = threadsDAO.create({ title: 'Active Thread', isActive: true });
    const activeThread = threadsDAO.getActive();
    expect(activeThread?.id).toBe(thread.id);
  });

  it('should return null if no active thread', () => {
    threadsDAO.create({ title: 'Inactive Thread', isActive: false });
    const activeThread = threadsDAO.getActive();
    expect(activeThread).toBeNull();
  });
});
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall