acp-vscode 0.3.0

package/__tests__/fetcher.test.js

@@ -0,0 +1,122 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const axios = require('axios');
+jest.mock('axios');
+
+let fetcher;
+let fetchIndex;
+let diskPaths;
+const cache = require('../src/cache');
+
+describe('fetcher', () => {
+  const tmp = path.join(os.tmpdir(), `acp-fetcher-${Date.now()}`);
+  const origCwd = process.cwd();
+
+  beforeAll(async () => {
+    await fs.ensureDir(tmp);
+    process.chdir(tmp);
+    // require after chdir so diskPaths uses tmp cwd
+    fetcher = require('../src/fetcher');
+    fetchIndex = fetcher.fetchIndex;
+    diskPaths = fetcher.diskPaths;
+  });
+
+  afterAll(async () => {
+    process.chdir(origCwd);
+    await fs.remove(tmp);
+  });
+
+  beforeEach(async () => {
+    cache.del('index');
+    const { DISK_CACHE_DIR } = diskPaths();
+    await fs.remove(DISK_CACHE_DIR).catch(() => {});
+    axios.get.mockReset();
+  });
+
+  test('fetches remote when no cache', async () => {
+    axios.get.mockResolvedValue({ status: 200, data: { prompts: [{ id: 'p' }] } });
+    const idx = await fetchIndex();
+    expect(idx).toEqual({ prompts: [{ id: 'p' }] });
+    // disk cache should exist
+    const { DISK_CACHE_FILE } = diskPaths();
+    expect(await fs.pathExists(DISK_CACHE_FILE)).toBe(true);
+  });
+
+  test('uses disk cache when fresh', async () => {
+    // write fresh disk cache
+    const payload = { prompts: [{ id: 'p2' }] };
+  const { DISK_CACHE_DIR, DISK_CACHE_FILE } = diskPaths();
+  await fs.ensureDir(DISK_CACHE_DIR);
+  await fs.writeJson(DISK_CACHE_FILE, { ts: Date.now(), payload });
+    const idx = await fetchIndex();
+    expect(idx).toEqual(payload);
+    // axios should not have been called
+    expect(axios.get).not.toHaveBeenCalled();
+  });
+
+  test('falls back to stale disk cache if network fails', async () => {
+    // write stale disk cache (old ts)
+    const payload = { prompts: [{ id: 'stale' }] };
+  const { DISK_CACHE_DIR, DISK_CACHE_FILE } = diskPaths();
+  await fs.ensureDir(DISK_CACHE_DIR);
+  await fs.writeJson(DISK_CACHE_FILE, { ts: Date.now() - (60 * 60 * 1000), payload });
+    axios.get.mockRejectedValue(new Error('network error'));
+    const idx = await fetchIndex();
+    expect(idx).toEqual(payload);
+  });
+
+  test('builds combined index and detects conflicts across repos', async () => {
+    // configure two repos that both contain a 'shared' prompt id
+    process.env.ACP_REPOS_JSON = JSON.stringify([
+      { id: 'r1', treeUrl: 'https://api/repo1', rawBase: 'https://raw1' },
+      { id: 'r2', treeUrl: 'https://api/repo2', rawBase: 'https://raw2' }
+    ]);
+
+    axios.get.mockImplementation((url) => {
+      // repo trees
+      if (url === 'https://api/repo1') {
+        return Promise.resolve({ status: 200, data: { tree: [
+          { path: 'prompts/p1.prompt.md', type: 'blob' },
+          { path: 'prompts/shared.prompt.md', type: 'blob' }
+        ] } });
+      }
+      if (url === 'https://api/repo2') {
+        return Promise.resolve({ status: 200, data: { tree: [
+          { path: 'prompts/p2.prompt.md', type: 'blob' },
+          { path: 'prompts/shared.prompt.md', type: 'blob' }
+        ] } });
+      }
+      // per-file raw content
+      if (url.startsWith('https://raw1/')) {
+        return Promise.resolve({ status: 200, data: '---\ntitle: "Repo One P1"\n---\ncontent' });
+      }
+      if (url.startsWith('https://raw2/')) {
+        return Promise.resolve({ status: 200, data: '---\ntitle: "Repo Two P2"\n---\ncontent' });
+      }
+      return Promise.reject(new Error('unexpected url ' + url));
+    });
+
+    const idx = await fetchIndex();
+
+    // repos metadata should be present
+    expect(idx._repos).toEqual([
+      { id: 'r1', treeUrl: 'https://api/repo1', rawBase: 'https://raw1' },
+      { id: 'r2', treeUrl: 'https://api/repo2', rawBase: 'https://raw2' }
+    ]);
+
+    // prompts should include items from both repos
+    const pids = idx.prompts.map(p => `${p.repo}:${p.id}`).sort();
+    expect(pids).toEqual(expect.arrayContaining(['r1:p1', 'r2:p2', 'r1:shared', 'r2:shared']));
+
+    // conflict should include 'shared'
+    expect(idx._conflicts).toContain('shared');
+
+    // shared items should have repo metadata and be two entries
+    const shared = idx.prompts.filter(p => p.id === 'shared');
+    expect(shared.length).toBe(2);
+    expect(new Set(shared.map(s => s.repo))).toEqual(new Set(['r1','r2']));
+
+    delete process.env.ACP_REPOS_JSON;
+  });
+});

package/__tests__/install-ambiguous.test.js

@@ -0,0 +1,14 @@
+const { performInstall } = require('../src/commands/install');
+const cache = require('../src/cache');
+
+test('performInstall errors on ambiguous names', async () => {
+  cache.set('index', {
+    prompts: [ { id: 'abc', name: 'ABC', repo: 'r1' }, { id: 'abcd', name: 'ABCD', repo: 'r2' } ],
+    chatmodes: [],
+    instructions: []
+  });
+  // ambiguous prefix 'ab' matches multiple entries and should cause an error (exitCode 2)
+  await performInstall({ target: 'workspace', type: 'prompts', names: ['ab'], options: {} });
+  expect(process.exitCode).toBe(2);
+  cache.del('index');
+});

package/__tests__/install-command-multi.test.js

@@ -0,0 +1,37 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const axios = require('axios');
+jest.mock('axios');
+
+let performInstall;
+const cache = require('../src/cache');
+
+beforeEach(() => {
+  cache.del('index');
+  delete process.env.ACP_REPOS_JSON;
+});
+
+test('performInstall resolves repo-qualified names and installs only matching repo item (dry-run)', async () => {
+  // build an index in ACP_INDEX_JSON for simplicity
+  const idx = {
+    prompts: [
+      { id: 'shared', name: 'Shared One', repo: 'r1', url: null, content: 'x' },
+      { id: 'shared', name: 'Shared Two', repo: 'r2', url: null, content: 'y' }
+    ],
+    chatmodes: [],
+    instructions: []
+  };
+  process.env.ACP_INDEX_JSON = JSON.stringify(idx);
+  ({ performInstall } = require('../src/commands/install'));
+
+  // performInstall in package-mode with repo-qualified name
+  const tmp = path.join(os.tmpdir(), `acp-install-cmd-${Date.now()}`);
+  await fs.ensureDir(tmp);
+
+  // Use dry-run so no files are written, but ensure resolution finds correct item
+  await performInstall({ target: 'r1:shared', names: [], options: { 'dry-run': true }, workspaceDir: tmp });
+
+  // cleanup env
+  delete process.env.ACP_INDEX_JSON;
+});

package/__tests__/install-command.test.js

@@ -0,0 +1,40 @@
+jest.mock('../src/fetcher');
+const { fetchIndex } = require('../src/fetcher');
+const cache = require('../src/cache');
+const { performInstall } = require('../src/commands/install');
+const fs = require('fs-extra');
+
+const FIXTURE_INDEX = {
+  prompts: [{ id: 'p1', name: 'Prompt One' }],
+  chatmodes: [{ id: 'c1', name: 'Chat Mode One' }],
+  instructions: [{ id: 'i1', name: 'Instruction One' }]
+};
+
+beforeEach(() => {
+  fetchIndex.mockResolvedValue(FIXTURE_INDEX);
+  cache.del('index');
+});
+
+test('performInstall installs a named package when present', async () => {
+  // create a temp dir to act as workspace
+  const tmp = require('path').join(require('os').tmpdir(), `acp-test-${Date.now()}`);
+  await fs.ensureDir(tmp);
+  await performInstall({ target: 'p1', type: undefined, names: [], options: { verbose: false }, workspaceDir: tmp });
+  // performInstall returns undefined but should have written files under tmp/.github or prompts
+  const gh = require('path').join(tmp, '.github');
+  const exists = await fs.pathExists(gh);
+  expect(exists).toBe(true);
+});
+
+test('performInstall errors when package not found', async () => {
+  // capture console.error
+  const errs = [];
+  const orig = console.error;
+  console.error = (...args) => errs.push(args.join(' '));
+  try {
+    await performInstall({ target: 'nonexistent-package', type: undefined, names: [], options: {} });
+    expect(errs.some(e => e.includes('not found'))).toBeTruthy();
+  } finally {
+    console.error = orig;
+  }
+});

package/__tests__/install-extra.test.js

@@ -0,0 +1,50 @@
+jest.mock('prompts');
+const prompts = require('prompts');
+const cache = require('../src/cache');
+
+afterEach(() => {
+  cache.del('index');
+  delete process.env.ACP_INDEX_JSON;
+  // restore TTY flag
+  if (process.stdin && typeof process.stdin.isTTY !== 'undefined') process.stdin.isTTY = false;
+});
+
+test('performInstall package-mode when package not found sets exitCode 2', async () => {
+  const { performInstall } = require('../src/commands/install');
+  // ensure cache empty
+  cache.del('index');
+  // call with a package name that does not exist
+  await performInstall({ target: 'no-such-package', options: {} });
+  expect(process.exitCode).toBe(2);
+});
+
+test('performInstall interactive prompt skip path logs skipped by user', async () => {
+  // simulate interactive TTY
+  if (process.stdin) process.stdin.isTTY = true;
+  // mock prompts to respond with ok: false
+  prompts.mockResolvedValue({ ok: false });
+  process.env.ACP_INDEX_JSON = JSON.stringify({ prompts: [{ id: 'p1', name: 'One', repo: 'r1' }], chatmodes: [], instructions: [] });
+  const { performInstall } = require('../src/commands/install');
+  const logs = [];
+  jest.spyOn(console, 'log').mockImplementation((...args) => logs.push(args.join(' ')));
+  await performInstall({ target: 'workspace', type: 'prompts', names: [], options: {} });
+  expect(logs.some(l => l.includes('Skipped by user'))).toBe(true);
+  console.log.mockRestore();
+});
+
+test('performInstall handles fetchIndex throwing by setting exitCode 2', async () => {
+  // mock fetcher to throw
+  jest.resetModules();
+  jest.doMock('../src/fetcher', () => ({
+    fetchIndex: async () => { throw new Error('network'); },
+    diskPaths: () => ({ DISK_CACHE_FILE: '/nonexistent' })
+  }));
+  const { performInstall } = require('../src/commands/install');
+  // ensure cache cleared
+  cache.del('index');
+  await performInstall({ target: 'workspace', type: 'prompts', names: [], options: {} });
+  expect(process.exitCode).toBe(2);
+  // cleanup mocked module
+  jest.dontMock('../src/fetcher');
+  jest.resetModules();
+});

package/__tests__/install-multiple-names.test.js

@@ -0,0 +1,35 @@
+jest.mock('../src/fetcher');
+const { fetchIndex } = require('../src/fetcher');
+const cache = require('../src/cache');
+const { performInstall } = require('../src/commands/install');
+
+beforeEach(() => {
+  cache.del('index');
+});
+
+test('performInstall handles multiple names (dry-run) and reports both', async () => {
+  const FIXTURE_INDEX = {
+    prompts: [
+      { id: 'p1', name: 'Prompt One' },
+      { id: 'p2', name: 'Prompt Two' }
+    ],
+    chatmodes: [],
+    instructions: []
+  };
+  fetchIndex.mockResolvedValue(FIXTURE_INDEX);
+
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+  try {
+    await performInstall({ target: 'workspace', type: 'prompts', names: ['p1', 'p2'], options: { 'dry-run': true } });
+    // Find dry-run line and ensure both prompts are listed
+    const dryRunLines = logs.filter(l => l.includes('[dry-run]'));
+    expect(dryRunLines.length).toBeGreaterThan(0);
+    const listed = logs.filter(l => l.includes('Prompt One') || l.includes('Prompt Two'));
+    expect(listed.some(l => l.includes('Prompt One'))).toBeTruthy();
+    expect(listed.some(l => l.includes('Prompt Two'))).toBeTruthy();
+  } finally {
+    console.log = origLog;
+  }
+});

package/__tests__/installer-multi.test.js

@@ -0,0 +1,22 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { installFiles } = require('../src/installer');
+
+test('install preserves repo id in filenames and writes workspace files for multi-repo items', async () => {
+  const tmp = path.join(os.tmpdir(), `acp-install-multi-${Date.now()}`);
+  await fs.ensureDir(tmp);
+  const items = [
+    { id: 'one', name: 'One', content: 'a', repo: 'r1' },
+    { id: 'one', name: 'One from r2', content: 'b', repo: 'r2' }
+  ];
+  const dest = await installFiles({ items, type: 'prompts', target: 'workspace', workspaceDir: tmp });
+  expect(await fs.pathExists(dest)).toBe(true);
+  const files = await fs.readdir(dest);
+  // Should have written two files for both items
+  expect(files.length).toBe(2);
+  // Read files and ensure contents correspond
+  const contents = await Promise.all(files.map(f => fs.readFile(path.join(dest, f), 'utf8')));
+  expect(contents.some(c => c.includes('a'))).toBe(true);
+  expect(contents.some(c => c.includes('b'))).toBe(true);
+});

package/__tests__/installer-raw-and-resolve.test.js

@@ -0,0 +1,62 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const axios = require('axios');
+jest.mock('axios');
+
+const { installFiles, removeFiles } = require('../src/installer');
+const { performInstall } = require('../src/commands/install');
+const cache = require('../src/cache');
+
+test('installFiles fetches raw content when item.url is present and writes workspace file', async () => {
+  const tmp = path.join(os.tmpdir(), `acp-install-raw-${Date.now()}`);
+  await fs.ensureDir(tmp);
+  axios.get.mockResolvedValueOnce({ data: 'RAW-CONTENT' });
+  const items = [{ id: 'raw1', name: 'Raw One', url: 'https://raw.example/raw1' }];
+  const dest = await installFiles({ items, type: 'prompts', target: 'workspace', workspaceDir: tmp });
+  const files = await fs.readdir(dest);
+  expect(files.length).toBe(1);
+  const content = await fs.readFile(path.join(dest, files[0]), 'utf8');
+  expect(content).toBe('RAW-CONTENT');
+});
+
+test('installFiles writes prompts to user prompts folder', async () => {
+  const tmp = path.join(os.tmpdir(), `acp-installer-user-prompts-${Date.now()}`);
+  await fs.ensureDir(tmp);
+  const origHome = process.env.HOME;
+  process.env.HOME = tmp;
+
+  const items = [{ id: 'up1', name: 'User Prompt', content: 'u' }];
+  const dest = await installFiles({ items, type: 'prompts', target: 'user' });
+  expect(await fs.pathExists(dest)).toBe(true);
+  const files = await fs.readdir(dest);
+  expect(files.length).toBeGreaterThan(0);
+
+  if (origHome === undefined) delete process.env.HOME; else process.env.HOME = origHome;
+});
+
+test('performInstall resolves names across types when multiple types and uses dry-run', async () => {
+  // build index with same id in prompts and chatmodes
+  cache.set('index', {
+    prompts: [{ id: 'multi', name: 'Multi Prompt', repo: 'r1' }],
+    chatmodes: [{ id: 'multi', name: 'Multi Chat', repo: 'r2' }],
+    instructions: []
+  });
+  const logs = [];
+  jest.spyOn(console, 'log').mockImplementation((...args) => logs.push(args.join(' ')));
+  await performInstall({ target: 'workspace', type: 'all', names: ['multi'], options: { 'dry-run': true } });
+  // dry-run should report two installs (one prompts and one chatmodes)
+  expect(logs.some(l => l.includes('Would install')) || logs.some(l => l.includes('[dry-run]'))).toBe(true);
+  console.log.mockRestore();
+  cache.del('index');
+});
+
+test('removeFiles can remove files that are not JSON by matching filename', async () => {
+  const tmp = path.join(os.tmpdir(), `acp-uninstall-nonjson-${Date.now()}`);
+  const base = path.join(tmp, '.github', 'prompts');
+  await fs.ensureDir(base);
+  const fname = path.join(base, 'plainfile.prompt.md');
+  await fs.writeFile(fname, 'plain text not json');
+  const removed = await removeFiles({ names: ['plainfile.prompt.md'], type: 'prompts', target: 'workspace', workspaceDir: tmp });
+  expect(removed).toBe(1);
+});

package/__tests__/installer-user.test.js

@@ -0,0 +1,19 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { installFiles } = require('../src/installer');
+
+test('install writes non-prompts to user .github folder', async () => {
+  const tmp = path.join(os.tmpdir(), `acp-installer-user-${Date.now()}`);
+  await fs.ensureDir(tmp);
+  const origHome = process.env.HOME;
+  process.env.HOME = tmp;
+
+  const items = [{ id: 'c1', name: 'ChatMode', content: 'x' }];
+  const dest = await installFiles({ items, type: 'chatmodes', target: 'user' });
+  expect(await fs.pathExists(dest)).toBe(true);
+  const files = await fs.readdir(dest);
+  expect(files.length).toBeGreaterThan(0);
+
+  if (origHome === undefined) delete process.env.HOME; else process.env.HOME = origHome;
+});

package/__tests__/installer.test.js

@@ -0,0 +1,14 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { installFiles } = require('../src/installer');
+
+test('install to workspace', async () => {
+  const tmp = path.join(os.tmpdir(), `acp-test-${Date.now()}`);
+  await fs.ensureDir(tmp);
+  const items = [{ id: 'one', name: 'One', content: { body: 'x' } }];
+  const dest = await installFiles({ items, type: 'prompts', target: 'workspace', workspaceDir: tmp });
+  expect(await fs.pathExists(dest)).toBe(true);
+  const files = await fs.readdir(dest);
+  expect(files.length).toBeGreaterThan(0);
+});

package/__tests__/list-format.test.js

@@ -0,0 +1,31 @@
+const { formatListLines } = require('../src/commands/list');
+
+describe('formatListLines', () => {
+  test('produces header, delimiter and aligned rows', () => {
+    const items = [
+      { type: 'prompt', id: 'p1', name: 'Short' },
+      { type: 'chatmode', id: 'longer-id', name: 'A longer name' },
+      { type: 'instruction', id: 'i', name: '' }
+    ];
+    const lines = formatListLines(items);
+    // Should have header and delimiter as first two lines
+    expect(lines.length).toBeGreaterThanOrEqual(5);
+    const header = lines[0];
+    const delim = lines[1];
+    expect(header).toMatch(/Type\s+ID\s+Name/);
+    expect(delim).toMatch(/^-+\s+-+\s+-+/);
+
+    // All subsequent rows should have the same column boundaries as header
+    const headerCols = header.split(/\s{2,}/);
+    const colWidths = headerCols.map(c => c.length);
+
+    for (let i = 2; i < lines.length; i++) {
+      const cols = lines[i].split(/\s{2,}/);
+      expect(cols.length).toBe(3);
+      // each column should be at least as wide as header's column
+      for (let j = 0; j < 3; j++) {
+        expect(cols[j].length).toBeGreaterThanOrEqual(colWidths[j]);
+      }
+    }
+  });
+});

package/__tests__/list-items-conflict.test.js

@@ -0,0 +1,15 @@
+const { listItems, formatListLines } = require('../src/commands/list');
+
+test('listItems includes repo prefix for conflicted ids and formatListLines emits header', () => {
+  const idx = {
+    prompts: [ { id: 'shared', name: 'Shared Prompt', repo: 'r1' } ],
+    chatmodes: [],
+    instructions: [],
+    _conflicts: ['shared']
+  };
+  const items = listItems(idx, 'prompts');
+  expect(items.length).toBe(1);
+  expect(items[0].id).toBe('r1:shared');
+  const lines = formatListLines(items);
+  expect(lines[0]).toMatch(/Type\s+ID\s+Name/);
+});

package/__tests__/list-json.test.js

@@ -0,0 +1,35 @@
+const cache = require('../src/cache');
+
+function makeCli() {
+  const cli = {
+    _action: null,
+    command() { return cli; },
+    option() { return cli; },
+    action(fn) { cli._action = fn; return cli; }
+  };
+  return cli;
+}
+
+describe('list JSON output', () => {
+  afterEach(() => {
+    cache.del('index');
+    delete process.env.ACP_INDEX_JSON;
+  });
+
+  test('listCommand emits valid JSON when --json is passed', async () => {
+    process.env.ACP_INDEX_JSON = JSON.stringify({ prompts: [{ id: 'p1', name: 'Prompt One', repo: 'r1' }], chatmodes: [], instructions: [], _conflicts: [] });
+    const stubCli = makeCli();
+    const lc = require('../src/commands/list');
+    lc.listCommand(stubCli);
+    const logs = [];
+    jest.spyOn(console, 'log').mockImplementation((...args) => logs.push(args.join(' ')));
+    await stubCli._action('prompts', { refresh: true, verbose: false, json: true });
+    expect(logs.length).toBeGreaterThan(0);
+    // The first log should be parseable JSON representing an array
+    const parsed = JSON.parse(logs.join('\n'));
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.length).toBe(1);
+    expect(parsed[0].id).toBe('p1');
+    console.log.mockRestore();
+  });
+});

package/__tests__/search-index.test.js

@@ -0,0 +1,14 @@
+const { searchIndex } = require('../src/commands/search');
+
+test('searchIndex returns results with repo-qualified ids when conflicts exist', () => {
+  const idx = {
+    prompts: [ { id: 'shared', name: 'Shared Prompt', repo: 'r1' } ],
+    chatmodes: [ { id: 'other', name: 'Other Mode', repo: 'r2' } ],
+    instructions: [],
+    _conflicts: ['shared']
+  };
+  const res = searchIndex(idx, 'shared');
+  expect(res.length).toBe(1);
+  expect(res[0].id).toBe('r1:shared');
+  expect(res[0].type).toBe('prompt');
+});

package/__tests__/search-json.test.js

@@ -0,0 +1,34 @@
+const cache = require('../src/cache');
+
+function makeCli() {
+  const cli = {
+    _action: null,
+    command() { return cli; },
+    option() { return cli; },
+    action(fn) { cli._action = fn; return cli; }
+  };
+  return cli;
+}
+
+describe('search JSON output', () => {
+  afterEach(() => {
+    cache.del('index');
+    delete process.env.ACP_INDEX_JSON;
+  });
+
+  test('searchCommand emits valid JSON when --json is passed', async () => {
+    process.env.ACP_INDEX_JSON = JSON.stringify({ prompts: [{ id: 's1', name: 'SearchMe', repo: 'r1' }], chatmodes: [], instructions: [], _conflicts: [] });
+    const stubCli = makeCli();
+    const sc = require('../src/commands/search');
+    sc.searchCommand(stubCli);
+    const logs = [];
+    jest.spyOn(console, 'log').mockImplementation((...args) => logs.push(args.join(' ')));
+    await stubCli._action('searchme', { refresh: true, verbose: false, json: true });
+    expect(logs.length).toBeGreaterThan(0);
+    const parsed = JSON.parse(logs.join('\n'));
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.length).toBe(1);
+    expect(parsed[0].id).toBe('s1');
+    console.log.mockRestore();
+  });
+});

package/__tests__/uninstall-prefixed.test.js

@@ -0,0 +1,52 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { removeFiles } = require('../src/installer');
+
+test('removeFiles removes repo-prefixed files in workspace by repo:id and id', async () => {
+  const tmp = path.join(os.tmpdir(), `acp-uninstall-prefixed-${Date.now()}`);
+  const base = path.join(tmp, '.github', 'prompts');
+  await fs.ensureDir(base);
+  // simulate files written with repo prefix
+  const f1 = path.join(base, 'r1-shared.prompt.md');
+  const f2 = path.join(base, 'r2-shared.prompt.md');
+  await fs.writeFile(f1, JSON.stringify({ id: 'shared', repo: 'r1' }));
+  await fs.writeFile(f2, JSON.stringify({ id: 'shared', repo: 'r2' }));
+
+  // Remove r1:shared should remove only r1 file
+  let removed = await removeFiles({ names: ['r1:shared'], type: 'prompts', target: 'workspace', workspaceDir: tmp });
+  expect(removed).toBe(1);
+  expect(await fs.pathExists(f1)).toBe(false);
+  expect(await fs.pathExists(f2)).toBe(true);
+
+  // Remove remaining by id-only should remove the other
+  removed = await removeFiles({ names: ['shared'], type: 'prompts', target: 'workspace', workspaceDir: tmp });
+  expect(removed).toBe(1);
+  expect(await fs.pathExists(f2)).toBe(false);
+});
+
+test('removeFiles removes repo-prefixed files in user dir by repo:id and id', async () => {
+  // For user path use getVsCodeUserDir location but override HOME via env to a tmp dir
+  const tmp = path.join(os.tmpdir(), `acp-uninstall-prefixed-user-${Date.now()}`);
+  await fs.ensureDir(tmp);
+  // set HOME so getVsCodeUserDir resolves under tmp
+  const origHome = process.env.HOME;
+  process.env.HOME = tmp;
+  const userPrompts = path.join(tmp, 'Library', 'Application Support', 'Code', 'User', 'prompts');
+  await fs.ensureDir(userPrompts);
+  const f1 = path.join(userPrompts, 'r1-shared.prompt.md');
+  const f2 = path.join(userPrompts, 'r2-shared.prompt.md');
+  await fs.writeFile(f1, JSON.stringify({ id: 'shared', repo: 'r1' }));
+  await fs.writeFile(f2, JSON.stringify({ id: 'shared', repo: 'r2' }));
+
+  let removed = await removeFiles({ names: ['r2:shared'], type: 'prompts', target: 'user' });
+  expect(removed).toBe(1);
+  expect(await fs.pathExists(f2)).toBe(false);
+
+  removed = await removeFiles({ names: ['shared'], type: 'prompts', target: 'user' });
+  expect(removed).toBe(1);
+  expect(await fs.pathExists(f1)).toBe(false);
+
+  // restore HOME
+  if (origHome === undefined) delete process.env.HOME; else process.env.HOME = origHome;
+});

package/__tests__/uninstall.test.js

@@ -0,0 +1,21 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { removeFiles } = require('../src/installer');
+
+test('removeFiles removes named files in workspace', async () => {
+  const tmp = path.join(os.tmpdir(), `acp-uninstall-${Date.now()}`);
+  const base = path.join(tmp, '.github', 'prompts');
+  await fs.ensureDir(base);
+  const f1 = path.join(base, 'one.json');
+  const f2 = path.join(base, 'two.json');
+  await fs.writeJson(f1, { id: 'one', name: 'One' });
+  await fs.writeJson(f2, { id: 'two', name: 'Two' });
+
+  const removed = await removeFiles({ names: ['one'], type: 'prompts', target: 'workspace', workspaceDir: tmp });
+  expect(removed).toBe(1);
+  const exists1 = await fs.pathExists(f1);
+  const exists2 = await fs.pathExists(f2);
+  expect(exists1).toBe(false);
+  expect(exists2).toBe(true);
+});