Claude/fix summarize feature (#76)

* fix: include js-yaml dependency in extension package

The js-yaml module was declared in dependencies but wasn't being
bundled in the packaged extension. Updated the package script to
copy js-yaml to out/node_modules/ during packaging.

This fixes the "Cannot find module 'js-yaml'" error when using
the generateTagsCurrentNote command (AI Summarize feature).

Resolves issue with TagParser requiring js-yaml for YAML frontmatter parsing.

* test: add comprehensive unit tests for TagParser

Adds 17 unit tests covering:
- hasFrontmatter() detection
- parseTags() for array/list/string formats
- writeTags() for adding/updating frontmatter
- removeTags() edge cases

These tests verify js-yaml integration and would catch dependency
issues during development (but not packaging issues).

* refactor: improve dependency bundling and test determinism

1. Replace hardcoded package script with bundle-deps.js:
   - Dynamic dependency resolution using require.resolve
   - Handles packages that don't export package.json
   - Cleaner package.json script
   - More maintainable (no version numbers hardcoded)

2. Improve TagParser tests with sinon fake timers:
   - Use fixed timestamp (2024-01-15T12:00:00.000Z) for deterministic tests
   - Verify exact tagged-at timestamp value, not just presence
   - Tests now properly validate timestamp behavior

These improvements address code review feedback for better
maintainability and test robustness.

---------

Co-authored-by: Claude <[email protected]>

Author: jsonify

package.json

@@ -1189,7 +1189,7 @@
     "pretest": "pnpm run compile",
     "test": "node ./out/test/runTest.js",
     "test:unit": "mocha --require out/test/setup.js out/test/unit/**/*.test.js",
-    "package": "mkdir -p out/node_modules && cp -rL node_modules/.pnpm/[email protected]/node_modules/marked out/node_modules/ && cp -rL node_modules/.pnpm/[email protected]/node_modules/markdown-it-regex out/node_modules/ && vsce package --no-dependencies",
+    "package": "node scripts/bundle-deps.js && vsce package --no-dependencies",
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
     "release:patch": "standard-version --release-as patch && pnpm run package",
     "release:minor": "standard-version --release-as minor && pnpm run package",

scripts/bundle-deps.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+/**
+ * Bundle dependencies for VS Code extension packaging
+ *
+ * This script copies required runtime dependencies to out/node_modules/
+ * so they're included in the packaged .vsix file when using --no-dependencies.
+ *
+ * This is necessary because vsce's --no-dependencies flag excludes all node_modules,
+ * but we need certain runtime dependencies available in the extension.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Dependencies that need to be bundled with the extension
+const DEPS_TO_BUNDLE = [
+  'marked',
+  'markdown-it-regex',
+  'js-yaml'
+];
+
+const OUT_DIR = path.join(__dirname, '..', 'out', 'node_modules');
+
+/**
+ * Resolve the actual location of a package in pnpm's node_modules
+ * @param {string} packageName - Name of the package to resolve
+ * @returns {string} Absolute path to the package directory
+ */
+function resolvePackagePath(packageName) {
+  try {
+    // First try to resolve package.json directly
+    try {
+      const packageJsonPath = require.resolve(`${packageName}/package.json`, {
+        paths: [path.join(__dirname, '..')]
+      });
+      return path.dirname(packageJsonPath);
+    } catch (e) {
+      // If package.json is not exported, resolve the main entry point instead
+      const mainPath = require.resolve(packageName, {
+        paths: [path.join(__dirname, '..')]
+      });
+
+      // Walk up the directory tree to find the package root
+      let currentDir = path.dirname(mainPath);
+      while (currentDir !== path.dirname(currentDir)) {
+        const potentialPackageJson = path.join(currentDir, 'package.json');
+        if (fs.existsSync(potentialPackageJson)) {
+          const pkg = JSON.parse(fs.readFileSync(potentialPackageJson, 'utf8'));
+          if (pkg.name === packageName) {
+            return currentDir;
+          }
+        }
+        currentDir = path.dirname(currentDir);
+      }
+
+      throw new Error(`Could not find package root for ${packageName}`);
+    }
+  } catch (error) {
+    console.error(`Error resolving ${packageName}:`, error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Recursively copy a directory
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ */
+function copyDir(src, dest) {
+  // Create destination directory
+  fs.mkdirSync(dest, { recursive: true });
+
+  // Read all entries in source directory
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Main bundling logic
+ */
+function bundleDependencies() {
+  console.log('Bundling dependencies for extension packaging...\n');
+
+  // Create out/node_modules directory if it doesn't exist
+  fs.mkdirSync(OUT_DIR, { recursive: true });
+
+  // Bundle each dependency
+  for (const dep of DEPS_TO_BUNDLE) {
+    console.log(`Bundling ${dep}...`);
+
+    const sourcePath = resolvePackagePath(dep);
+    const destPath = path.join(OUT_DIR, dep);
+
+    // Copy the package
+    copyDir(sourcePath, destPath);
+
+    console.log(`  ✓ Copied from ${sourcePath}`);
+    console.log(`  ✓ To ${destPath}\n`);
+  }
+
+  console.log(`✓ Successfully bundled ${DEPS_TO_BUNDLE.length} dependencies`);
+}
+
+// Run the bundling
+try {
+  bundleDependencies();
+} catch (error) {
+  console.error('Error bundling dependencies:', error);
+  process.exit(1);
+}

src/test/unit/TagParser.test.ts

@@ -0,0 +1,235 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { TagParser, NoteMetadata, NoteTag } from '../../tagging/TagParser';
+
+describe('TagParser', () => {
+  let clock: sinon.SinonFakeTimers;
+
+  beforeEach(() => {
+    // Use a fixed date for deterministic testing: 2024-01-15T12:00:00.000Z
+    clock = sinon.useFakeTimers(new Date('2024-01-15T12:00:00.000Z'));
+  });
+
+  afterEach(() => {
+    clock.restore();
+  });
+  describe('hasFrontmatter', () => {
+    it('should return true for content with YAML frontmatter', () => {
+      const content = `---
+tags: [test, example]
+---
+
+Note content`;
+
+      const hasFrontmatter = TagParser.hasFrontmatter(content);
+      expect(hasFrontmatter).to.be.true;
+    });
+
+    it('should return false for content without frontmatter', () => {
+      const content = 'Just a regular note without frontmatter';
+
+      const hasFrontmatter = TagParser.hasFrontmatter(content);
+      expect(hasFrontmatter).to.be.false;
+    });
+
+    it('should return false for empty content', () => {
+      const content = '';
+
+      const hasFrontmatter = TagParser.hasFrontmatter(content);
+      expect(hasFrontmatter).to.be.false;
+    });
+  });
+
+  describe('parseTags', () => {
+    it('should parse tags from YAML frontmatter array', () => {
+      const content = `---
+tags: [bug, urgent, feature]
+---
+
+Note content`;
+
+      const metadata = TagParser.parseTags(content);
+      expect(metadata.tags).to.have.lengthOf(3);
+      expect(metadata.tags.map(t => t.name)).to.have.members(['bug', 'urgent', 'feature']);
+      expect(metadata.tags[0].source).to.equal('manual');
+      expect(metadata.tags[0].confidence).to.equal(1.0);
+    });
+
+    it('should parse tags from YAML frontmatter list format', () => {
+      const content = `---
+tags:
+  - project
+  - frontend
+  - typescript
+---
+
+Note content`;
+
+      const metadata = TagParser.parseTags(content);
+      expect(metadata.tags).to.have.lengthOf(3);
+      expect(metadata.tags.map(t => t.name)).to.have.members(['project', 'frontend', 'typescript']);
+    });
+
+    it('should return empty array for content without tags', () => {
+      const content = `---
+title: My Note
+---
+
+Content`;
+
+      const metadata = TagParser.parseTags(content);
+      expect(metadata.tags).to.have.lengthOf(0);
+    });
+
+    it('should return empty array for content without frontmatter', () => {
+      const content = 'Regular note content';
+
+      const metadata = TagParser.parseTags(content);
+      expect(metadata.tags).to.have.lengthOf(0);
+    });
+
+    it('should parse tagged-at timestamp when present', () => {
+      const content = `---
+tags: [bug, feature]
+tagged-at: 2025-01-01T00:00:00.000Z
+---
+
+Content`;
+
+      const metadata = TagParser.parseTags(content);
+      expect(metadata.tags).to.have.lengthOf(2);
+      expect(metadata.lastTagged).to.be.instanceOf(Date);
+      expect(metadata.lastTagged?.toISOString()).to.equal('2025-01-01T00:00:00.000Z');
+    });
+
+    it('should parse old string format tags', () => {
+      const content = `---
+tags: bug, feature, urgent
+---
+
+Content`;
+
+      const metadata = TagParser.parseTags(content);
+      expect(metadata.tags).to.have.lengthOf(3);
+      expect(metadata.tags.map(t => t.name)).to.have.members(['bug', 'feature', 'urgent']);
+    });
+  });
+
+  describe('writeTags', () => {
+    it('should add frontmatter with tags to content without frontmatter', () => {
+      const content = 'Note content';
+      const metadata: NoteMetadata = {
+        tags: [
+          { name: 'bug', confidence: 1.0, source: 'manual', addedAt: new Date() },
+          { name: 'feature', confidence: 1.0, source: 'manual', addedAt: new Date() }
+        ]
+      };
+
+      const result = TagParser.writeTags(content, metadata);
+      expect(result).to.include('---');
+      expect(result).to.include('tags: [bug, feature]');
+      expect(result).to.include('Note content');
+    });
+
+    it('should update existing frontmatter with new tags', () => {
+      const content = `---
+title: My Note
+---
+
+Content`;
+      const metadata: NoteMetadata = {
+        tags: [
+          { name: 'urgent', confidence: 1.0, source: 'manual', addedAt: new Date() },
+          { name: 'todo', confidence: 1.0, source: 'manual', addedAt: new Date() }
+        ]
+      };
+
+      const result = TagParser.writeTags(content, metadata);
+      expect(result).to.include('title: My Note');
+      expect(result).to.include('tags: [urgent, todo]');
+    });
+
+    it('should preserve existing frontmatter fields', () => {
+      const content = `---
+title: My Note
+author: John
+---
+
+Content`;
+      const metadata: NoteMetadata = {
+        tags: [
+          { name: 'new', confidence: 1.0, source: 'manual', addedAt: new Date() }
+        ]
+      };
+
+      const result = TagParser.writeTags(content, metadata);
+      expect(result).to.include('title: My Note');
+      expect(result).to.include('author: John');
+      expect(result).to.include('tags: [new]');
+    });
+
+    it('should add tagged-at timestamp when tags are added', () => {
+      const content = 'Content';
+      const metadata: NoteMetadata = {
+        tags: [
+          { name: 'test', confidence: 1.0, source: 'manual', addedAt: new Date() }
+        ]
+      };
+
+      const result = TagParser.writeTags(content, metadata);
+      // YAML may quote the timestamp string, so check for both formats
+      const hasTimestamp = result.includes('tagged-at: 2024-01-15T12:00:00.000Z') ||
+                          result.includes("tagged-at: '2024-01-15T12:00:00.000Z'");
+      expect(hasTimestamp).to.be.true;
+    });
+
+    it('should remove tags field when metadata has empty tags', () => {
+      const content = `---
+tags: [bug, feature]
+title: My Note
+---
+
+Content`;
+      const metadata: NoteMetadata = {
+        tags: []
+      };
+
+      const result = TagParser.writeTags(content, metadata);
+      expect(result).to.not.include('tags:');
+      expect(result).to.include('title: My Note');
+    });
+  });
+
+  describe('removeTags', () => {
+    it('should remove all tags from frontmatter', () => {
+      const content = `---
+tags: [bug, feature]
+title: My Note
+---
+
+Content`;
+
+      const result = TagParser.removeTags(content);
+      expect(result).to.include('title: My Note');
+      expect(result).to.not.include('tags:');
+    });
+
+    it('should handle content without tags gracefully', () => {
+      const content = `---
+title: My Note
+---
+
+Content`;
+
+      const result = TagParser.removeTags(content);
+      expect(result).to.include('title: My Note');
+    });
+
+    it('should handle content without frontmatter gracefully', () => {
+      const content = 'Just content';
+
+      const result = TagParser.removeTags(content);
+      expect(result).to.equal('Just content');
+    });
+  });
+});