canopycms 0.0.0 → 0.0.2

package/src/__integration__/workflows/editing-workflow.test.ts

@@ -1,205 +0,0 @@
-/**
- * Integration tests for the editing workflow.
- * Tests the complete lifecycle: create branch → edit content → save → commit
- * Tests go through the HTTP API layer.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { simpleGit } from 'simple-git'
-
-import { createTestWorkspace, type TestWorkspace } from '../test-utils/test-workspace'
-import { createMockAuthPlugin } from '../test-utils/multi-user'
-import { createApiClient } from '../test-utils/api-client'
-import { BLOG_SCHEMA } from '../fixtures/schemas'
-import type { BranchResponse } from '../../api/branch'
-import { initTestRepo } from '../../test-utils'
-
-describe('Editing Workflow Integration', () => {
-  let workspace: TestWorkspace
-  let editorClient: Awaited<ReturnType<typeof createApiClient>>
-
-  beforeEach(async () => {
-    workspace = await createTestWorkspace({
-      schema: BLOG_SCHEMA,
-    })
-
-    editorClient = await createApiClient({
-      config: workspace.config,
-      authPlugin: createMockAuthPlugin('editor'),
-      schema: BLOG_SCHEMA,
-    })
-  })
-
-  afterEach(async () => {
-    await workspace.cleanup()
-  })
-
-  it('completes full editing cycle: create → edit → save → commit', async () => {
-    // Create branch via API
-    const createResponse = await editorClient.post('/api/canopycms/branches', {
-      branch: 'feature/new-post',
-      title: 'Add blog post',
-    })
-
-    expect(createResponse.status).toBe(200)
-    const createData = await createResponse.json<BranchResponse>()
-    expect(createData.data?.branch.status).toBe('editing')
-    expect(createData.data?.branch.createdBy).toBe('test-editor')
-
-    // Get branch workspace path from response
-    const branchRoot = (createData.data?.branch as { workspaceRoot?: string })?.workspaceRoot
-
-    // Write content via API (will fail due to collection path bug, but test the structure)
-    const writeResponse = await editorClient.put(
-      '/api/canopycms/feature-new-post/content/posts/hello-world',
-      {
-        collection: 'content/posts',
-        slug: 'hello-world',
-        format: 'mdx',
-        data: {
-          title: 'Hello World',
-          author: 'Test Author',
-          date: '2024-01-01T00:00:00Z',
-          tags: ['intro', 'test'],
-        },
-        body: 'This is my first post!',
-      },
-    )
-
-    // TODO: This will fail until collection path bug is fixed
-    // expect(writeResponse.status).toBe(200)
-
-    // Commit changes (if write succeeded)
-    if (writeResponse.status === 200 && branchRoot) {
-      await initTestRepo(branchRoot)
-      const git = simpleGit({ baseDir: branchRoot })
-      await git.add(['.'])
-      await git.commit('Add hello world post')
-
-      // Verify commit exists
-      const log = await git.log()
-      expect(log.latest?.message).toBe('Add hello world post')
-    }
-  })
-
-  it('handles concurrent edits on different branches', async () => {
-    const editor1Client = editorClient
-    const editor2Client = await createApiClient({
-      config: workspace.config,
-      authPlugin: createMockAuthPlugin('admin'),
-      schema: BLOG_SCHEMA,
-    })
-
-    // Both editors create branches simultaneously
-    const [branchA, branchB] = await Promise.all([
-      editor1Client.post('/api/canopycms/branches', {
-        branch: 'feature/editor1-post',
-        title: 'Editor 1 Post',
-      }),
-      editor2Client.post('/api/canopycms/branches', {
-        branch: 'feature/editor2-post',
-        title: 'Editor 2 Post',
-      }),
-    ])
-
-    expect(branchA.status).toBe(200)
-    expect(branchB.status).toBe(200)
-
-    // Both write content simultaneously (will fail due to collection bug)
-    await Promise.all([
-      editor1Client.put('/api/canopycms/feature-editor1-post/content/posts/post-a', {
-        collection: 'content/posts',
-        slug: 'post-a',
-        format: 'mdx',
-        data: {
-          title: 'Post A',
-          author: 'Editor 1',
-          date: '2024-01-01',
-          tags: ['test'],
-        },
-        body: 'Content A',
-      }),
-      editor2Client.put('/api/canopycms/feature-editor2-post/content/posts/post-b', {
-        collection: 'content/posts',
-        slug: 'post-b',
-        format: 'mdx',
-        data: {
-          title: 'Post B',
-          author: 'Editor 2',
-          date: '2024-01-02',
-          tags: ['test'],
-        },
-        body: 'Content B',
-      }),
-    ])
-
-    // TODO: Verify isolation once collection bug is fixed
-    // Each user should only see their own content
-  })
-
-  it('supports multi-file editing with proper git commits', async () => {
-    const adminClient = await createApiClient({
-      config: workspace.config,
-      authPlugin: createMockAuthPlugin('admin'),
-      schema: BLOG_SCHEMA,
-    })
-
-    // Create branch
-    const createResponse = await adminClient.post('/api/canopycms/branches', {
-      branch: 'feature/multi-file',
-      title: 'Multi-file editing',
-    })
-
-    expect(createResponse.status).toBe(200)
-    const createData = await createResponse.json<BranchResponse>()
-    const branchRoot = (createData.data?.branch as { workspaceRoot?: string })?.workspaceRoot
-
-    // Write multiple posts via API
-    await Promise.all([
-      adminClient.put('/api/canopycms/feature-multi-file/content/posts/post-1', {
-        collection: 'content/posts',
-        slug: 'post-1',
-        format: 'mdx',
-        data: {
-          title: 'Post 1',
-          author: 'Admin',
-          date: '2024-01-01',
-          tags: ['test'],
-        },
-        body: 'First post',
-      }),
-      adminClient.put('/api/canopycms/feature-multi-file/content/posts/post-2', {
-        collection: 'content/posts',
-        slug: 'post-2',
-        format: 'mdx',
-        data: {
-          title: 'Post 2',
-          author: 'Admin',
-          date: '2024-01-02',
-          tags: ['test'],
-        },
-        body: 'Second post',
-      }),
-      adminClient.put('/api/canopycms/feature-multi-file/content/posts/post-3', {
-        collection: 'content/posts',
-        slug: 'post-3',
-        format: 'mdx',
-        data: {
-          title: 'Post 3',
-          author: 'Admin',
-          date: '2024-01-03',
-          tags: ['test'],
-        },
-        body: 'Third post',
-      }),
-    ])
-
-    // TODO: Once collection bug is fixed, commit and verify
-    if (branchRoot) {
-      const git = simpleGit({ baseDir: branchRoot })
-      await git.status()
-      // Should have files if writes succeeded
-      // expect(status.files.length).toBeGreaterThan(0)
-    }
-  })
-})

package/src/__integration__/workflows/review-workflow.test.ts

@@ -1,260 +0,0 @@
-/**
- * Integration tests for the review workflow.
- * Tests submission, review comments, request changes, and approval.
- * Tests go through the HTTP API layer.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-
-import { createTestWorkspace, type TestWorkspace } from '../test-utils/test-workspace'
-import { createMockAuthPlugin } from '../test-utils/multi-user'
-import { createApiClient } from '../test-utils/api-client'
-import { BLOG_SCHEMA } from '../fixtures/schemas'
-import type { BranchResponse } from '../../api/branch'
-import type {
-  CommentsResponse,
-  AddCommentResponse,
-  ResolveCommentResponse,
-} from '../../api/comments'
-
-describe('Review Workflow Integration', () => {
-  let workspace: TestWorkspace
-  let editorClient: Awaited<ReturnType<typeof createApiClient>>
-  let reviewerClient: Awaited<ReturnType<typeof createApiClient>>
-  let adminClient: Awaited<ReturnType<typeof createApiClient>>
-
-  beforeEach(async () => {
-    workspace = await createTestWorkspace({
-      schema: BLOG_SCHEMA,
-    })
-
-    editorClient = await createApiClient({
-      config: workspace.config,
-      authPlugin: createMockAuthPlugin('editor'),
-      schema: BLOG_SCHEMA,
-    })
-
-    reviewerClient = await createApiClient({
-      config: workspace.config,
-      authPlugin: createMockAuthPlugin('reviewer'),
-      schema: BLOG_SCHEMA,
-    })
-
-    adminClient = await createApiClient({
-      config: workspace.config,
-      authPlugin: createMockAuthPlugin('admin'),
-      schema: BLOG_SCHEMA,
-    })
-  })
-
-  afterEach(async () => {
-    await workspace.cleanup()
-  })
-
-  it('completes full review cycle: submit → review → request changes → resubmit → approve', async () => {
-    // STEP 1: Editor creates branch
-    const createResponse = await editorClient.post('/api/canopycms/branches', {
-      branch: 'feature/review-test',
-      title: 'Test Review Workflow',
-    })
-
-    expect(createResponse.status).toBe(200)
-    const createData = await createResponse.json<BranchResponse>()
-    expect(createData.data?.branch.status).toBe('editing')
-
-    // STEP 2: Editor writes content (will fail due to collection bug)
-    await editorClient.put('/api/canopycms/feature-review-test/content/posts/test-post', {
-      collection: 'content/posts',
-      slug: 'test-post',
-      format: 'mdx',
-      data: {
-        title: 'Test Post',
-        author: 'Test Editor',
-        date: '2024-01-01',
-        tags: ['test'],
-      },
-      body: 'This needs review',
-    })
-
-    // STEP 3: Editor submits for review
-    const submitResponse = await editorClient.post('/api/canopycms/feature-review-test/submit', {
-      message: 'Ready for review',
-    })
-
-    expect(submitResponse.status).toBe(200)
-    const submitData = await submitResponse.json<BranchResponse>()
-    expect(submitData.data?.branch.status).toBe('submitted')
-
-    // STEP 4: Reviewer adds comment
-    const commentResponse = await reviewerClient.post(
-      '/api/canopycms/feature-review-test/comments',
-      {
-        text: 'Please add more details to the introduction',
-        type: 'entry',
-        entryPath: 'content/posts/test-post',
-      },
-    )
-
-    expect(commentResponse.status).toBe(200)
-
-    // STEP 5: Reviewer requests changes
-    const requestChangesResponse = await reviewerClient.post(
-      '/api/canopycms/feature-review-test/request-changes',
-      {
-        message: 'Needs more details',
-      },
-    )
-
-    expect(requestChangesResponse.status).toBe(200)
-    const requestChangesData = await requestChangesResponse.json<BranchResponse>()
-    expect(requestChangesData.data?.branch.status).toBe('editing')
-
-    // STEP 6: Editor updates content and resubmits
-    await editorClient.put('/api/canopycms/feature-review-test/content/posts/test-post', {
-      collection: 'content/posts',
-      slug: 'test-post',
-      format: 'mdx',
-      data: {
-        title: 'Test Post',
-        author: 'Test Editor',
-        date: '2024-01-01',
-        tags: ['test'],
-      },
-      body: 'This needs review. Added more details as requested.',
-    })
-
-    const resubmitResponse = await editorClient.post('/api/canopycms/feature-review-test/submit', {
-      message: 'Updated with more details',
-    })
-
-    expect(resubmitResponse.status).toBe(200)
-
-    // STEP 7: Reviewer approves
-    const approveResponse = await reviewerClient.post(
-      '/api/canopycms/feature-review-test/approve',
-      {
-        message: 'Looks good!',
-      },
-    )
-
-    expect(approveResponse.status).toBe(200)
-    const approveData = await approveResponse.json<BranchResponse>()
-    expect(approveData.data?.branch.status).toBe('approved')
-  })
-
-  it('allows multiple reviewers to comment', async () => {
-    // Create and submit branch
-    await editorClient.post('/api/canopycms/branches', {
-      branch: 'feature/multi-reviewer',
-      title: 'Multi Reviewer Test',
-    })
-
-    await editorClient.post('/api/canopycms/feature-multi-reviewer/submit', {
-      message: 'Ready for review',
-    })
-
-    // Both reviewer and admin add comments concurrently
-    // (CommentStore now handles concurrency with optimistic locking)
-    const [reviewerComment, adminComment] = await Promise.all([
-      reviewerClient.post('/api/canopycms/feature-multi-reviewer/comments', {
-        text: 'Reviewer comment',
-        type: 'branch',
-      }),
-      adminClient.post('/api/canopycms/feature-multi-reviewer/comments', {
-        text: 'Admin comment',
-        type: 'branch',
-      }),
-    ])
-
-    expect(reviewerComment.status).toBe(200)
-    expect(adminComment.status).toBe(200)
-
-    // List all comments
-    const listResponse = await reviewerClient.get('/api/canopycms/feature-multi-reviewer/comments')
-
-    expect(listResponse.status).toBe(200)
-    const listData = await listResponse.json<CommentsResponse>()
-    expect(listData.data?.threads.length).toBeGreaterThanOrEqual(2)
-  })
-
-  it('enforces reviewer permissions', async () => {
-    // Editor creates and submits branch
-    await editorClient.post('/api/canopycms/branches', {
-      branch: 'feature/permission-test',
-      title: 'Permission Test',
-    })
-
-    await editorClient.post('/api/canopycms/feature-permission-test/submit', {
-      message: 'Ready',
-    })
-
-    // Editor (not a reviewer) tries to approve - should fail
-    const approveResponse = await editorClient.post(
-      '/api/canopycms/feature-permission-test/approve',
-      {
-        message: 'Approving my own work',
-      },
-    )
-
-    expect(approveResponse.status).toBe(403)
-  })
-
-  it('supports comment threads and resolution', async () => {
-    // Create and submit branch
-    await editorClient.post('/api/canopycms/branches', {
-      branch: 'feature/comment-threads',
-      title: 'Comment Threads Test',
-    })
-
-    await editorClient.post('/api/canopycms/feature-comment-threads/submit', {
-      message: 'Ready',
-    })
-
-    // Reviewer adds a comment
-    const commentResponse = await reviewerClient.post(
-      '/api/canopycms/feature-comment-threads/comments',
-      {
-        text: 'This needs fixing',
-        type: 'branch',
-      },
-    )
-
-    expect(commentResponse.status).toBe(200)
-    const commentData = await commentResponse.json<AddCommentResponse>()
-    const threadId = commentData.data?.threadId
-
-    // Reviewer resolves the comment thread
-    const resolveResponse = await reviewerClient.post(
-      `/api/canopycms/feature-comment-threads/comments/${threadId}/resolve`,
-      {},
-    )
-
-    expect(resolveResponse.status).toBe(200)
-    const resolveData = await resolveResponse.json<ResolveCommentResponse>()
-    expect(resolveData.data?.resolved).toBe(true)
-  })
-
-  it('allows withdrawal from review', async () => {
-    // Create and submit branch
-    await editorClient.post('/api/canopycms/branches', {
-      branch: 'feature/withdraw-test',
-      title: 'Withdraw Test',
-    })
-
-    const submitResponse = await editorClient.post('/api/canopycms/feature-withdraw-test/submit', {
-      message: 'Ready',
-    })
-
-    expect(submitResponse.status).toBe(200)
-
-    // Editor withdraws submission
-    const withdrawResponse = await editorClient.post(
-      '/api/canopycms/feature-withdraw-test/withdraw',
-      {},
-    )
-
-    expect(withdrawResponse.status).toBe(200)
-    const withdrawData = await withdrawResponse.json<BranchResponse>()
-    expect(withdrawData.data?.branch.status).toBe('editing')
-  })
-})

package/src/ai/__tests__/build.integration.test.ts

@@ -1,224 +0,0 @@
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
-
-import { defineCanopyTestConfig } from '../../config-test'
-import { flattenSchema, type RootCollectionConfig } from '../../config'
-import { ContentStore } from '../../content-store'
-import { unsafeAsLogicalPath, unsafeAsEntrySlug } from '../../paths/test-utils'
-import { generateAIContentFiles } from '../../build/generate-ai-content'
-import type { AIManifest } from '../types'
-
-const tmpDir = () => fs.mkdtemp(path.join(os.tmpdir(), 'canopycms-ai-build-'))
-
-const testSchema: RootCollectionConfig = {
-  collections: [
-    {
-      name: 'posts',
-      path: 'posts',
-      entries: [
-        {
-          name: 'post',
-          format: 'md' as const,
-          schema: [
-            { name: 'title', type: 'string' as const },
-            { name: 'published', type: 'boolean' as const },
-          ],
-          default: true,
-        },
-      ],
-    },
-    {
-      name: 'settings',
-      path: 'settings',
-      entries: [
-        {
-          name: 'setting',
-          format: 'json' as const,
-          schema: [{ name: 'siteName', type: 'string' as const }],
-        },
-      ],
-    },
-  ],
-}
-
-async function setupContent(root: string, schema: RootCollectionConfig) {
-  const config = defineCanopyTestConfig({ schema })
-  const flat = flattenSchema(schema, config.contentRoot)
-  const store = new ContentStore(root, flat)
-
-  await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('hello-world'), {
-    format: 'md',
-    data: { title: 'Hello World', published: true },
-    body: '# Hello\n\nFirst post.',
-  })
-
-  await store.write(unsafeAsLogicalPath('content/posts'), unsafeAsEntrySlug('second'), {
-    format: 'md',
-    data: { title: 'Second', published: false },
-    body: 'Second post.',
-  })
-
-  await store.write(unsafeAsLogicalPath('content/settings'), unsafeAsEntrySlug('site'), {
-    format: 'json',
-    data: { siteName: 'TestSite' },
-  })
-
-  return { config, flat, store }
-}
-
-describe('generateAIContentFiles', () => {
-  let contentRoot: string
-  let outputDir: string
-
-  beforeEach(async () => {
-    contentRoot = await tmpDir()
-    outputDir = await tmpDir()
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('writes all expected files to disk', async () => {
-    const { config, flat } = await setupContent(contentRoot, testSchema)
-    vi.spyOn(process, 'cwd').mockReturnValue(contentRoot)
-
-    const result = await generateAIContentFiles({
-      config: { ...config, mode: 'dev' },
-      entrySchemaRegistry: {},
-      outputDir,
-      _testFlatSchema: flat,
-    })
-
-    expect(result.fileCount).toBeGreaterThan(0)
-
-    // manifest.json exists and is valid
-    const manifestPath = path.join(outputDir, 'manifest.json')
-    const manifestContent = await fs.readFile(manifestPath, 'utf-8')
-    const manifest = JSON.parse(manifestContent) as AIManifest
-    expect(manifest.generated).toBeTruthy()
-    expect(manifest.collections.length).toBeGreaterThan(0)
-
-    // Individual entry files
-    const postFile = path.join(outputDir, 'posts', 'hello-world.md')
-    const postContent = await fs.readFile(postFile, 'utf-8')
-    expect(postContent).toContain('Hello World')
-
-    // Collection all.md
-    const allPostsFile = path.join(outputDir, 'posts', 'all.md')
-    const allPostsContent = await fs.readFile(allPostsFile, 'utf-8')
-    expect(allPostsContent).toContain('Hello World')
-    expect(allPostsContent).toContain('Second')
-
-    // Settings
-    const settingFile = path.join(outputDir, 'settings', 'site.md')
-    const settingContent = await fs.readFile(settingFile, 'utf-8')
-    expect(settingContent).toContain('TestSite')
-  })
-
-  it('file count matches actual files on disk', async () => {
-    const { config, flat } = await setupContent(contentRoot, testSchema)
-    vi.spyOn(process, 'cwd').mockReturnValue(contentRoot)
-
-    const result = await generateAIContentFiles({
-      config: { ...config, mode: 'dev' },
-      entrySchemaRegistry: {},
-      outputDir,
-      _testFlatSchema: flat,
-    })
-
-    // Count files recursively on disk
-    const countFiles = async (dir: string): Promise<number> => {
-      let count = 0
-      const entries = await fs.readdir(dir, { withFileTypes: true })
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          count += await countFiles(path.join(dir, entry.name))
-        } else {
-          count++
-        }
-      }
-      return count
-    }
-
-    const filesOnDisk = await countFiles(outputDir)
-    expect(filesOnDisk).toBe(result.fileCount)
-  })
-
-  it('writes bundles to bundles/ subdirectory', async () => {
-    const { config, flat } = await setupContent(contentRoot, testSchema)
-    vi.spyOn(process, 'cwd').mockReturnValue(contentRoot)
-
-    await generateAIContentFiles({
-      config: { ...config, mode: 'dev' },
-      entrySchemaRegistry: {},
-      outputDir,
-      _testFlatSchema: flat,
-      aiConfig: {
-        bundles: [
-          {
-            name: 'published',
-            description: 'Published posts',
-            filter: {
-              collections: ['posts'],
-              where: (entry) => entry.data.published === true,
-            },
-          },
-        ],
-      },
-    })
-
-    const bundleFile = path.join(outputDir, 'bundles', 'published.md')
-    const bundleContent = await fs.readFile(bundleFile, 'utf-8')
-    expect(bundleContent).toContain('Hello World')
-    expect(bundleContent).not.toContain('Second')
-  })
-
-  it('rejects path traversal in bundle names', async () => {
-    const { config, flat } = await setupContent(contentRoot, testSchema)
-    vi.spyOn(process, 'cwd').mockReturnValue(contentRoot)
-
-    await expect(
-      generateAIContentFiles({
-        config: { ...config, mode: 'dev' },
-        entrySchemaRegistry: {},
-        outputDir,
-        _testFlatSchema: flat,
-        aiConfig: {
-          bundles: [
-            {
-              name: '../../etc/malicious',
-              filter: { collections: ['posts'] },
-            },
-          ],
-        },
-      }),
-    ).rejects.toThrow('Invalid bundle name')
-  })
-
-  it('creates correct directory structure', async () => {
-    const { config, flat } = await setupContent(contentRoot, testSchema)
-    vi.spyOn(process, 'cwd').mockReturnValue(contentRoot)
-
-    await generateAIContentFiles({
-      config: { ...config, mode: 'dev' },
-      entrySchemaRegistry: {},
-      outputDir,
-      _testFlatSchema: flat,
-    })
-
-    // Check directory structure
-    const topLevel = await fs.readdir(outputDir)
-    expect(topLevel).toContain('manifest.json')
-    expect(topLevel).toContain('posts')
-    expect(topLevel).toContain('settings')
-
-    const postsDir = await fs.readdir(path.join(outputDir, 'posts'))
-    expect(postsDir).toContain('all.md')
-    expect(postsDir).toContain('hello-world.md')
-    expect(postsDir).toContain('second.md')
-  })
-})