@plaited/development-skills 0.4.0 → 0.4.1

package/LICENSE

@@ -1,6 +1,6 @@
 ISC License
 
-Copyright (c) 2025 Plaited
+Copyright (c) 2026 Plaited Labs
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

package/README.md

@@ -1,5 +1,10 @@
 # development-skills
 
+[![npm version](https://img.shields.io/npm/v/@plaited/development-skills.svg)](https://www.npmjs.com/package/@plaited/development-skills)
+[![CI](https://github.com/plaited/acp-harness/actions/workflows/ci.yml/badge.svg)](https://github.com/plaited/development-skills/actions/workflows/ci.yml)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+
+
 TypeScript LSP, code documentation, and validation tools. Available as both a CLI tool and as installable skills for AI coding agents.
 
 ## CLI Tool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaited/development-skills",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Development skills for Claude Code - TypeScript LSP, code documentation, and validation tools",
   "license": "ISC",
   "engines": {

package/src/resolve-file-path.ts

@@ -1,28 +1,52 @@
+import { join } from 'node:path'
+
+/**
+ * Check if a path looks like a file path (vs a package specifier)
+ *
+ * @remarks
+ * File paths typically contain a `/` and end with a file extension.
+ * Package specifiers are bare like `lodash` or scoped like `@org/pkg`.
+ * Scoped packages starting with `@` are excluded even if they have extensions.
+ */
+const looksLikeFilePath = (path: string): boolean => {
+  // Scoped packages like @org/pkg/file.ts should use Bun.resolve()
+  if (path.startsWith('@')) return false
+  // Contains a slash and ends with a common source file extension
+  return path.includes('/') && /\.(tsx?|jsx?|mjs|cjs|json)$/.test(path)
+}
+
 /**
  * Resolve a file path to an absolute path
  *
  * @remarks
  * Handles three types of paths:
  * - Absolute paths (starting with `/`) - returned as-is
- * - Relative paths (starting with `.`) - resolved from cwd
+ * - Relative paths (starting with `.` or looking like `src/foo.ts`) - resolved from cwd
  * - Package export paths (e.g., `plaited/workshop/get-paths.ts`) - resolved via Bun.resolve()
  */
 export const resolveFilePath = async (filePath: string): Promise<string> => {
+  const cwd = process.cwd()
+
   // Absolute path
   if (filePath.startsWith('/')) {
     return filePath
   }
 
-  // Relative path from cwd
+  // Explicit relative path from cwd (starts with . or ..)
   if (filePath.startsWith('.')) {
-    return `${process.cwd()}/${filePath}`
+    return join(cwd, filePath)
+  }
+
+  // Implicit relative path (looks like a file path, e.g., src/utils/foo.ts)
+  if (looksLikeFilePath(filePath)) {
+    return join(cwd, filePath)
   }
 
   // Try package export path resolution
   try {
-    return await Bun.resolve(filePath, process.cwd())
+    return await Bun.resolve(filePath, cwd)
   } catch {
     // Fall back to relative path from cwd
-    return `${process.cwd()}/${filePath}`
+    return join(cwd, filePath)
   }
 }

package/src/tests/resolve-file-path.spec.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'bun:test'
+import { join } from 'node:path'
 import { resolveFilePath } from '../resolve-file-path.ts'
 
 describe('resolveFilePath', () => {
@@ -9,9 +10,10 @@ describe('resolveFilePath', () => {
   })
 
   test('resolves relative path from cwd', async () => {
-    const relativePath = './plugin/skills/typescript-lsp/scripts/tests/fixtures/sample.ts'
+    const relativePath = './src/resolve-file-path.ts'
     const result = await resolveFilePath(relativePath)
-    expect(result).toBe(`${process.cwd()}/${relativePath}`)
+    // join() normalizes paths, removing the ./
+    expect(result).toBe(join(process.cwd(), relativePath))
   })
 
   test('resolves package export path via Bun.resolve', async () => {
@@ -28,6 +30,46 @@ describe('resolveFilePath', () => {
     const invalidPath = 'nonexistent-package/file.ts'
     const result = await resolveFilePath(invalidPath)
 
-    expect(result).toBe(`${process.cwd()}/${invalidPath}`)
+    expect(result).toBe(join(process.cwd(), invalidPath))
+  })
+
+  test('resolves implicit relative path (src/foo.ts format) from cwd', async () => {
+    // Paths that look like file paths (contain / and end with extension)
+    // should resolve from cwd without trying Bun.resolve()
+    const implicitRelative = 'src/utils/parser.ts'
+    const result = await resolveFilePath(implicitRelative)
+
+    expect(result).toBe(join(process.cwd(), implicitRelative))
+  })
+
+  test('resolves various file extensions as implicit relative paths', async () => {
+    const extensions = ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs', 'json']
+
+    for (const ext of extensions) {
+      const path = `src/file.${ext}`
+      const result = await resolveFilePath(path)
+      expect(result).toBe(join(process.cwd(), path))
+    }
+  })
+
+  test('treats bare package names without extensions as package specifiers', async () => {
+    // A path like 'typescript' (no slash, no extension) should try Bun.resolve()
+    const barePkg = 'typescript'
+    const result = await resolveFilePath(barePkg)
+
+    // Should resolve to node_modules, not cwd/typescript
+    expect(result).toContain('node_modules/typescript')
+  })
+
+  test('treats scoped packages as package specifiers, not implicit file paths', async () => {
+    // Scoped packages like @org/pkg/file.ts should NOT be treated as implicit
+    // relative paths, even if they contain / and end with an extension.
+    // They should go through Bun.resolve() first, falling back to cwd if not found.
+    const scopedPkg = '@nonexistent/pkg/src/file.ts'
+    const result = await resolveFilePath(scopedPkg)
+
+    // Falls back to cwd since package doesn't exist, but importantly it tried
+    // Bun.resolve() first (doesn't match looksLikeFilePath due to @ prefix)
+    expect(result).toBe(join(process.cwd(), scopedPkg))
   })
 })