@openchamber/web 1.5.4 → 1.5.6

package/server/lib/git-service.js

@@ -432,6 +432,65 @@ export async function getDiff(directory, { path, staged = false, contextLines =
   }
 }
 
+export async function getRangeDiff(directory, { base, head, path, contextLines = 3 } = {}) {
+  const git = simpleGit(normalizeDirectoryPath(directory));
+  const baseRef = typeof base === 'string' ? base.trim() : '';
+  const headRef = typeof head === 'string' ? head.trim() : '';
+  if (!baseRef || !headRef) {
+    throw new Error('base and head are required');
+  }
+
+  // Prefer remote-tracking base ref so merged commits don't reappear
+  // when local base branch is stale (common when user stays on feature branch).
+  let resolvedBase = baseRef;
+  const originCandidate = `refs/remotes/origin/${baseRef}`;
+  try {
+    const verified = await git.raw(['rev-parse', '--verify', originCandidate]);
+    if (verified && verified.trim()) {
+      resolvedBase = `origin/${baseRef}`;
+    }
+  } catch {
+    // ignore
+  }
+
+  const args = ['diff', '--no-color'];
+  if (typeof contextLines === 'number' && !Number.isNaN(contextLines)) {
+    args.push(`-U${Math.max(0, contextLines)}`);
+  }
+  args.push(`${resolvedBase}...${headRef}`);
+  if (path) {
+    args.push('--', path);
+  }
+  const diff = await git.raw(args);
+  return diff;
+}
+
+export async function getRangeFiles(directory, { base, head } = {}) {
+  const git = simpleGit(normalizeDirectoryPath(directory));
+  const baseRef = typeof base === 'string' ? base.trim() : '';
+  const headRef = typeof head === 'string' ? head.trim() : '';
+  if (!baseRef || !headRef) {
+    throw new Error('base and head are required');
+  }
+
+  let resolvedBase = baseRef;
+  const originCandidate = `refs/remotes/origin/${baseRef}`;
+  try {
+    const verified = await git.raw(['rev-parse', '--verify', originCandidate]);
+    if (verified && verified.trim()) {
+      resolvedBase = `origin/${baseRef}`;
+    }
+  } catch {
+    // ignore
+  }
+
+  const raw = await git.raw(['diff', '--name-only', `${resolvedBase}...${headRef}`]);
+  return String(raw || '')
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean);
+}
+
 const IMAGE_EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'ico', 'bmp', 'avif'];
 
 function isImageFile(filePath) {

package/server/lib/github-auth.js

@@ -0,0 +1,149 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const OPENCHAMBER_DATA_DIR = process.env.OPENCHAMBER_DATA_DIR
+  ? path.resolve(process.env.OPENCHAMBER_DATA_DIR)
+  : path.join(os.homedir(), '.config', 'openchamber');
+
+const STORAGE_DIR = OPENCHAMBER_DATA_DIR;
+const STORAGE_FILE = path.join(STORAGE_DIR, 'github-auth.json');
+const SETTINGS_FILE = path.join(OPENCHAMBER_DATA_DIR, 'settings.json');
+
+const DEFAULT_GITHUB_CLIENT_ID = 'Ov23liNd8TxDcMXtAHHM';
+const DEFAULT_GITHUB_SCOPES = 'repo read:org workflow read:user user:email';
+
+function ensureStorageDir() {
+  if (!fs.existsSync(STORAGE_DIR)) {
+    fs.mkdirSync(STORAGE_DIR, { recursive: true });
+  }
+}
+
+function readJsonFile() {
+  ensureStorageDir();
+  if (!fs.existsSync(STORAGE_FILE)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(STORAGE_FILE, 'utf8');
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== 'object') {
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    console.error('Failed to read GitHub auth file:', error);
+    return null;
+  }
+}
+
+function writeJsonFile(payload) {
+  ensureStorageDir();
+  fs.writeFileSync(STORAGE_FILE, JSON.stringify(payload, null, 2), 'utf8');
+  try {
+    fs.chmodSync(STORAGE_FILE, 0o600);
+  } catch {
+    // best-effort
+  }
+}
+
+export function getGitHubAuth() {
+  const data = readJsonFile();
+  if (!data) {
+    return null;
+  }
+  const accessToken = typeof data.accessToken === 'string' ? data.accessToken : '';
+  if (!accessToken) {
+    return null;
+  }
+  return {
+    accessToken,
+    scope: typeof data.scope === 'string' ? data.scope : '',
+    tokenType: typeof data.tokenType === 'string' ? data.tokenType : 'bearer',
+    createdAt: typeof data.createdAt === 'number' ? data.createdAt : null,
+    user: data.user && typeof data.user === 'object'
+      ? {
+        login: typeof data.user.login === 'string' ? data.user.login : null,
+        avatarUrl: typeof data.user.avatarUrl === 'string' ? data.user.avatarUrl : null,
+        id: typeof data.user.id === 'number' ? data.user.id : null,
+        name: typeof data.user.name === 'string' ? data.user.name : null,
+        email: typeof data.user.email === 'string' ? data.user.email : null,
+      }
+      : null,
+  };
+}
+
+export function setGitHubAuth({ accessToken, scope, tokenType, user }) {
+  if (!accessToken || typeof accessToken !== 'string') {
+    throw new Error('accessToken is required');
+  }
+  writeJsonFile({
+    accessToken,
+    scope: typeof scope === 'string' ? scope : '',
+    tokenType: typeof tokenType === 'string' ? tokenType : 'bearer',
+    createdAt: Date.now(),
+    user: user && typeof user === 'object'
+      ? {
+        login: typeof user.login === 'string' ? user.login : undefined,
+        avatarUrl: typeof user.avatarUrl === 'string' ? user.avatarUrl : undefined,
+        id: typeof user.id === 'number' ? user.id : undefined,
+        name: typeof user.name === 'string' ? user.name : undefined,
+        email: typeof user.email === 'string' ? user.email : undefined,
+      }
+      : undefined,
+  });
+}
+
+export function clearGitHubAuth() {
+  try {
+    if (fs.existsSync(STORAGE_FILE)) {
+      fs.unlinkSync(STORAGE_FILE);
+    }
+    return true;
+  } catch (error) {
+    console.error('Failed to clear GitHub auth file:', error);
+    return false;
+  }
+}
+
+export function getGitHubClientId() {
+  const raw = process.env.OPENCHAMBER_GITHUB_CLIENT_ID;
+  const clientId = typeof raw === 'string' ? raw.trim() : '';
+  if (clientId) return clientId;
+
+  try {
+    if (fs.existsSync(SETTINGS_FILE)) {
+      const parsed = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
+      const stored = typeof parsed?.githubClientId === 'string' ? parsed.githubClientId.trim() : '';
+      if (stored) return stored;
+    }
+  } catch {
+    // ignore
+  }
+
+  return DEFAULT_GITHUB_CLIENT_ID;
+}
+
+export function getGitHubScopes() {
+  const raw = process.env.OPENCHAMBER_GITHUB_SCOPES;
+  const fromEnv = typeof raw === 'string' ? raw.trim() : '';
+  if (fromEnv) return fromEnv;
+
+  try {
+    if (fs.existsSync(SETTINGS_FILE)) {
+      const parsed = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
+      const stored = typeof parsed?.githubScopes === 'string' ? parsed.githubScopes.trim() : '';
+      if (stored) return stored;
+    }
+  } catch {
+    // ignore
+  }
+
+  return DEFAULT_GITHUB_SCOPES;
+}
+
+export const GITHUB_AUTH_FILE = STORAGE_FILE;

package/server/lib/github-device-flow.js

@@ -0,0 +1,50 @@
+const DEVICE_CODE_URL = 'https://github.com/login/device/code';
+const ACCESS_TOKEN_URL = 'https://github.com/login/oauth/access_token';
+const DEVICE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:device_code';
+
+const encodeForm = (params) => {
+  const body = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value == null) continue;
+    body.set(key, String(value));
+  }
+  return body.toString();
+};
+
+async function postForm(url, params) {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      Accept: 'application/json',
+    },
+    body: encodeForm(params),
+  });
+
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    const message = payload?.error_description || payload?.error || response.statusText;
+    const error = new Error(message || 'GitHub request failed');
+    error.status = response.status;
+    error.payload = payload;
+    throw error;
+  }
+  return payload;
+}
+
+export async function startDeviceFlow({ clientId, scope }) {
+  return postForm(DEVICE_CODE_URL, {
+    client_id: clientId,
+    scope,
+  });
+}
+
+export async function exchangeDeviceCode({ clientId, deviceCode }) {
+  // GitHub returns 200 with {error: 'authorization_pending'|...} for non-success states.
+  const payload = await postForm(ACCESS_TOKEN_URL, {
+    client_id: clientId,
+    device_code: deviceCode,
+    grant_type: DEVICE_GRANT_TYPE,
+  });
+  return payload;
+}

package/server/lib/github-octokit.js

@@ -0,0 +1,10 @@
+import { Octokit } from '@octokit/rest';
+import { getGitHubAuth } from './github-auth.js';
+
+export function getOctokitOrNull() {
+  const auth = getGitHubAuth();
+  if (!auth?.accessToken) {
+    return null;
+  }
+  return new Octokit({ auth: auth.accessToken });
+}

package/server/lib/github-repo.js

@@ -0,0 +1,55 @@
+import { getRemoteUrl } from './git-service.js';
+
+export const parseGitHubRemoteUrl = (raw) => {
+  if (typeof raw !== 'string') {
+    return null;
+  }
+  const value = raw.trim();
+  if (!value) {
+    return null;
+  }
+
+  // git@github.com:OWNER/REPO.git
+  if (value.startsWith('git@github.com:')) {
+    const rest = value.slice('git@github.com:'.length);
+    const cleaned = rest.endsWith('.git') ? rest.slice(0, -4) : rest;
+    const [owner, repo] = cleaned.split('/');
+    if (!owner || !repo) return null;
+    return { owner, repo, url: `https://github.com/${owner}/${repo}` };
+  }
+
+  // ssh://git@github.com/OWNER/REPO.git
+  if (value.startsWith('ssh://git@github.com/')) {
+    const rest = value.slice('ssh://git@github.com/'.length);
+    const cleaned = rest.endsWith('.git') ? rest.slice(0, -4) : rest;
+    const [owner, repo] = cleaned.split('/');
+    if (!owner || !repo) return null;
+    return { owner, repo, url: `https://github.com/${owner}/${repo}` };
+  }
+
+  // https://github.com/OWNER/REPO(.git)
+  try {
+    const url = new URL(value);
+    if (url.hostname !== 'github.com') {
+      return null;
+    }
+    const path = url.pathname.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleaned = path.endsWith('.git') ? path.slice(0, -4) : path;
+    const [owner, repo] = cleaned.split('/');
+    if (!owner || !repo) return null;
+    return { owner, repo, url: `https://github.com/${owner}/${repo}` };
+  } catch {
+    return null;
+  }
+};
+
+export async function resolveGitHubRepoFromDirectory(directory) {
+  const remoteUrl = await getRemoteUrl(directory).catch(() => null);
+  if (!remoteUrl) {
+    return { repo: null, remoteUrl: null };
+  }
+  return {
+    repo: parseGitHubRemoteUrl(remoteUrl),
+    remoteUrl,
+  };
+}

package/server/lib/opencode-config.js

@@ -5,9 +5,9 @@ import yaml from 'yaml';
 import { parse as parseJsonc } from 'jsonc-parser';
 
 const OPENCODE_CONFIG_DIR = path.join(os.homedir(), '.config', 'opencode');
-const AGENT_DIR = path.join(OPENCODE_CONFIG_DIR, 'agent');
-const COMMAND_DIR = path.join(OPENCODE_CONFIG_DIR, 'command');
-const SKILL_DIR = path.join(OPENCODE_CONFIG_DIR, 'skill');
+const AGENT_DIR = path.join(OPENCODE_CONFIG_DIR, 'agents');
+const COMMAND_DIR = path.join(OPENCODE_CONFIG_DIR, 'commands');
+const SKILL_DIR = path.join(OPENCODE_CONFIG_DIR, 'skills');
 const CONFIG_FILE = path.join(OPENCODE_CONFIG_DIR, 'opencode.json');
 const CUSTOM_CONFIG_FILE = process.env.OPENCODE_CONFIG
   ? path.resolve(process.env.OPENCODE_CONFIG)
@@ -51,10 +51,14 @@ function ensureDirs() {
  * Ensure project-level agent directory exists
  */
 function ensureProjectAgentDir(workingDirectory) {
-  const projectAgentDir = path.join(workingDirectory, '.opencode', 'agent');
+  const projectAgentDir = path.join(workingDirectory, '.opencode', 'agents');
   if (!fs.existsSync(projectAgentDir)) {
     fs.mkdirSync(projectAgentDir, { recursive: true });
   }
+  const legacyProjectAgentDir = path.join(workingDirectory, '.opencode', 'agent');
+  if (!fs.existsSync(legacyProjectAgentDir)) {
+    fs.mkdirSync(legacyProjectAgentDir, { recursive: true });
+  }
   return projectAgentDir;
 }
 
@@ -62,14 +66,20 @@ function ensureProjectAgentDir(workingDirectory) {
  * Get project-level agent path
  */
 function getProjectAgentPath(workingDirectory, agentName) {
-  return path.join(workingDirectory, '.opencode', 'agent', `${agentName}.md`);
+  const pluralPath = path.join(workingDirectory, '.opencode', 'agents', `${agentName}.md`);
+  const legacyPath = path.join(workingDirectory, '.opencode', 'agent', `${agentName}.md`);
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
 }
 
 /**
  * Get user-level agent path
  */
 function getUserAgentPath(agentName) {
-  return path.join(AGENT_DIR, `${agentName}.md`);
+  const pluralPath = path.join(AGENT_DIR, `${agentName}.md`);
+  const legacyPath = path.join(OPENCODE_CONFIG_DIR, 'agent', `${agentName}.md`);
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
 }
 
 /**
@@ -173,10 +183,14 @@ function getAgentPermissionSource(agentName, workingDirectory) {
  * Ensure project-level command directory exists
  */
 function ensureProjectCommandDir(workingDirectory) {
-  const projectCommandDir = path.join(workingDirectory, '.opencode', 'command');
+  const projectCommandDir = path.join(workingDirectory, '.opencode', 'commands');
   if (!fs.existsSync(projectCommandDir)) {
     fs.mkdirSync(projectCommandDir, { recursive: true });
   }
+  const legacyProjectCommandDir = path.join(workingDirectory, '.opencode', 'command');
+  if (!fs.existsSync(legacyProjectCommandDir)) {
+    fs.mkdirSync(legacyProjectCommandDir, { recursive: true });
+  }
   return projectCommandDir;
 }
 
@@ -184,14 +198,20 @@ function ensureProjectCommandDir(workingDirectory) {
  * Get project-level command path
  */
 function getProjectCommandPath(workingDirectory, commandName) {
-  return path.join(workingDirectory, '.opencode', 'command', `${commandName}.md`);
+  const pluralPath = path.join(workingDirectory, '.opencode', 'commands', `${commandName}.md`);
+  const legacyPath = path.join(workingDirectory, '.opencode', 'command', `${commandName}.md`);
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
 }
 
 /**
  * Get user-level command path
  */
 function getUserCommandPath(commandName) {
-  return path.join(COMMAND_DIR, `${commandName}.md`);
+  const pluralPath = path.join(COMMAND_DIR, `${commandName}.md`);
+  const legacyPath = path.join(OPENCODE_CONFIG_DIR, 'command', `${commandName}.md`);
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
 }
 
 /**
@@ -245,10 +265,14 @@ function getCommandWritePath(commandName, workingDirectory, requestedScope) {
  * Ensure project-level skill directory exists
  */
 function ensureProjectSkillDir(workingDirectory) {
-  const projectSkillDir = path.join(workingDirectory, '.opencode', 'skill');
+  const projectSkillDir = path.join(workingDirectory, '.opencode', 'skills');
   if (!fs.existsSync(projectSkillDir)) {
     fs.mkdirSync(projectSkillDir, { recursive: true });
   }
+  const legacyProjectSkillDir = path.join(workingDirectory, '.opencode', 'skill');
+  if (!fs.existsSync(legacyProjectSkillDir)) {
+    fs.mkdirSync(legacyProjectSkillDir, { recursive: true });
+  }
   return projectSkillDir;
 }
 
@@ -256,28 +280,40 @@ function ensureProjectSkillDir(workingDirectory) {
  * Get project-level skill directory path (.opencode/skill/{name}/)
  */
 function getProjectSkillDir(workingDirectory, skillName) {
-  return path.join(workingDirectory, '.opencode', 'skill', skillName);
+  const pluralPath = path.join(workingDirectory, '.opencode', 'skills', skillName);
+  const legacyPath = path.join(workingDirectory, '.opencode', 'skill', skillName);
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
 }
 
 /**
  * Get project-level skill SKILL.md path
  */
 function getProjectSkillPath(workingDirectory, skillName) {
-  return path.join(getProjectSkillDir(workingDirectory, skillName), 'SKILL.md');
+  const pluralPath = path.join(workingDirectory, '.opencode', 'skills', skillName, 'SKILL.md');
+  const legacyPath = path.join(workingDirectory, '.opencode', 'skill', skillName, 'SKILL.md');
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
 }
 
 /**
  * Get user-level skill directory path
  */
 function getUserSkillDir(skillName) {
-  return path.join(SKILL_DIR, skillName);
+  const pluralPath = path.join(SKILL_DIR, skillName);
+  const legacyPath = path.join(OPENCODE_CONFIG_DIR, 'skill', skillName);
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
 }
 
 /**
  * Get user-level skill SKILL.md path
  */
 function getUserSkillPath(skillName) {
-  return path.join(getUserSkillDir(skillName), 'SKILL.md');
+  const pluralPath = path.join(SKILL_DIR, skillName, 'SKILL.md');
+  const legacyPath = path.join(OPENCODE_CONFIG_DIR, 'skill', skillName, 'SKILL.md');
+  if (fs.existsSync(legacyPath) && !fs.existsSync(pluralPath)) return legacyPath;
+  return pluralPath;
 }
 
 /**
@@ -1463,9 +1499,9 @@ function discoverSkills(workingDirectory) {
     }
   };
   
-  // 1. Project level .opencode/skill/ (highest priority)
+  // 1. Project level .opencode/skills/ (highest priority)
   if (workingDirectory) {
-    const projectSkillDir = path.join(workingDirectory, '.opencode', 'skill');
+    const projectSkillDir = path.join(workingDirectory, '.opencode', 'skills');
     if (fs.existsSync(projectSkillDir)) {
       const entries = fs.readdirSync(projectSkillDir, { withFileTypes: true });
       for (const entry of entries) {
@@ -1477,6 +1513,19 @@ function discoverSkills(workingDirectory) {
         }
       }
     }
+
+    const legacyProjectSkillDir = path.join(workingDirectory, '.opencode', 'skill');
+    if (fs.existsSync(legacyProjectSkillDir)) {
+      const entries = fs.readdirSync(legacyProjectSkillDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillMdPath = path.join(legacyProjectSkillDir, entry.name, 'SKILL.md');
+          if (fs.existsSync(skillMdPath)) {
+            addSkill(entry.name, skillMdPath, SKILL_SCOPE.PROJECT, 'opencode');
+          }
+        }
+      }
+    }
     
     // 2. Claude-compatible .claude/skills/
     const claudeSkillDir = path.join(workingDirectory, '.claude', 'skills');
@@ -1493,7 +1542,7 @@ function discoverSkills(workingDirectory) {
     }
   }
   
-  // 3. User level ~/.config/opencode/skill/
+  // 3. User level ~/.config/opencode/skills/
   if (fs.existsSync(SKILL_DIR)) {
     const entries = fs.readdirSync(SKILL_DIR, { withFileTypes: true });
     for (const entry of entries) {
@@ -1505,6 +1554,19 @@ function discoverSkills(workingDirectory) {
       }
     }
   }
+
+  const legacyUserSkillDir = path.join(OPENCODE_CONFIG_DIR, 'skill');
+  if (fs.existsSync(legacyUserSkillDir)) {
+    const entries = fs.readdirSync(legacyUserSkillDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillMdPath = path.join(legacyUserSkillDir, entry.name, 'SKILL.md');
+        if (fs.existsSync(skillMdPath)) {
+          addSkill(entry.name, skillMdPath, SKILL_SCOPE.USER, 'opencode');
+        }
+      }
+    }
+  }
   
   return Array.from(skills.values());
 }

package/server/lib/skills-catalog/clawdhub/install.js

@@ -14,6 +14,17 @@ import { downloadClawdHubSkill, fetchClawdHubSkillInfo } from './api.js';
 
 const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
 
+function normalizeUserSkillDir(userSkillDir) {
+  if (!userSkillDir) return null;
+  const legacySkillDir = path.join(os.homedir(), '.config', 'opencode', 'skill');
+  const pluralSkillDir = path.join(os.homedir(), '.config', 'opencode', 'skills');
+  if (userSkillDir === legacySkillDir) {
+    if (fs.existsSync(legacySkillDir) && !fs.existsSync(pluralSkillDir)) return legacySkillDir;
+    return pluralSkillDir;
+  }
+  return userSkillDir;
+}
+
 function validateSkillName(skillName) {
   if (typeof skillName !== 'string') return false;
   if (skillName.length < 1 || skillName.length > 64) return false;
@@ -41,7 +52,7 @@ function getTargetSkillDir({ scope, workingDirectory, userSkillDir, skillName })
     throw new Error('workingDirectory is required for project installs');
   }
 
-  return path.join(workingDirectory, '.opencode', 'skill', skillName);
+  return path.join(workingDirectory, '.opencode', 'skills', skillName);
 }
 
 /**
@@ -71,6 +82,11 @@ export async function installSkillsFromClawdHub({
     return { ok: false, error: { kind: 'unknown', message: 'userSkillDir is required' } };
   }
 
+  const normalizedUserSkillDir = normalizeUserSkillDir(userSkillDir);
+  if (normalizedUserSkillDir) {
+    userSkillDir = normalizedUserSkillDir;
+  }
+
   if (scope === 'project' && !workingDirectory) {
     return { ok: false, error: { kind: 'invalidSource', message: 'Project installs require a directory parameter' } };
   }

package/server/lib/skills-catalog/install.js

@@ -7,6 +7,17 @@ import { parseSkillRepoSource } from './source.js';
 
 const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
 
+function normalizeUserSkillDir(userSkillDir) {
+  if (!userSkillDir) return null;
+  const legacySkillDir = path.join(os.homedir(), '.config', 'opencode', 'skill');
+  const pluralSkillDir = path.join(os.homedir(), '.config', 'opencode', 'skills');
+  if (userSkillDir === legacySkillDir) {
+    if (fs.existsSync(legacySkillDir) && !fs.existsSync(pluralSkillDir)) return legacySkillDir;
+    return pluralSkillDir;
+  }
+  return userSkillDir;
+}
+
 function validateSkillName(skillName) {
   if (typeof skillName !== 'string') return false;
   if (skillName.length < 1 || skillName.length > 64) return false;
@@ -103,7 +114,7 @@ function getTargetSkillDir({ scope, workingDirectory, userSkillDir, skillName })
     throw new Error('workingDirectory is required for project installs');
   }
 
-  return path.join(workingDirectory, '.opencode', 'skill', skillName);
+  return path.join(workingDirectory, '.opencode', 'skills', skillName);
 }
 
 export async function installSkillsFromRepository({
@@ -123,14 +134,19 @@ export async function installSkillsFromRepository({
     return { ok: false, error: gitCheck.error };
   }
 
-  if (scope !== 'user' && scope !== 'project') {
-    return { ok: false, error: { kind: 'invalidSource', message: 'Invalid scope' } };
+  const normalizedUserSkillDir = normalizeUserSkillDir(userSkillDir);
+  if (normalizedUserSkillDir) {
+    userSkillDir = normalizedUserSkillDir;
   }
 
   if (!userSkillDir) {
     return { ok: false, error: { kind: 'unknown', message: 'userSkillDir is required' } };
   }
 
+  if (scope !== 'user' && scope !== 'project') {
+    return { ok: false, error: { kind: 'invalidSource', message: 'Invalid scope' } };
+  }
+
   if (scope === 'project' && !workingDirectory) {
     return { ok: false, error: { kind: 'invalidSource', message: 'Project installs require a directory parameter' } };
   }