@rbbtsn0w/adg 0.1.0-alpha.1

package/vendor/skills/src/test-utils.ts

@@ -0,0 +1,73 @@
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { stripTerminalEscapes } from './sanitize.ts';
+
+// const PROJECT_ROOT = join(import.meta.dirname, '..');
+const CLI_PATH = join(import.meta.dirname, 'cli.ts');
+
+export function stripAnsi(str: string): string {
+  return stripTerminalEscapes(str);
+}
+
+export function stripLogo(str: string): string {
+  return str
+    .split('\n')
+    .filter((line) => !line.includes('███') && !line.includes('╔') && !line.includes('╚'))
+    .join('\n')
+    .replace(/^\n+/, '');
+}
+
+export function hasLogo(str: string): boolean {
+  return str.includes('███') || str.includes('╔') || str.includes('╚');
+}
+
+export function runCli(
+  args: string[],
+  cwd?: string,
+  env?: Record<string, string>,
+  timeout?: number
+): { stdout: string; stderr: string; exitCode: number } {
+  try {
+    const output = execSync(`node "${CLI_PATH}" ${args.join(' ')}`, {
+      encoding: 'utf-8',
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: env ? { ...process.env, ...env } : undefined,
+      timeout: timeout ?? 30000,
+    });
+    return { stdout: stripAnsi(output), stderr: '', exitCode: 0 };
+  } catch (error: any) {
+    return {
+      stdout: stripAnsi(error.stdout || ''),
+      stderr: stripAnsi(error.stderr || ''),
+      exitCode: error.status || 1,
+    };
+  }
+}
+
+export function runCliOutput(args: string[], cwd?: string): string {
+  const result = runCli(args, cwd);
+  return result.stdout || result.stderr;
+}
+
+export function runCliWithInput(
+  args: string[],
+  input: string,
+  cwd?: string
+): { stdout: string; stderr: string; exitCode: number } {
+  try {
+    const output = execSync(`node "${CLI_PATH}" ${args.join(' ')}`, {
+      encoding: 'utf-8',
+      cwd,
+      input: input + '\n',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { stdout: stripAnsi(output), stderr: '', exitCode: 0 };
+  } catch (error: any) {
+    return {
+      stdout: stripAnsi(error.stdout || ''),
+      stderr: stripAnsi(error.stderr || ''),
+      exitCode: error.status || 1,
+    };
+  }
+}

package/vendor/skills/src/types.ts

@@ -0,0 +1,128 @@
+export type AgentType =
+  | 'aider-desk'
+  | 'amp'
+  | 'antigravity'
+  | 'antigravity-cli'
+  | 'astrbot'
+  | 'autohand-code'
+  | 'augment'
+  | 'bob'
+  | 'claude-code'
+  | 'openclaw'
+  | 'cline'
+  | 'codearts-agent'
+  | 'codebuddy'
+  | 'codemaker'
+  | 'codestudio'
+  | 'codex'
+  | 'command-code'
+  | 'continue'
+  | 'cortex'
+  | 'crush'
+  | 'cursor'
+  | 'deepagents'
+  | 'devin'
+  | 'dexto'
+  | 'droid'
+  | 'firebender'
+  | 'forgecode'
+  | 'gemini-cli'
+  | 'github-copilot'
+  | 'goose'
+  | 'hermes-agent'
+  | 'inference-sh'
+  | 'iflow-cli'
+  | 'jazz'
+  | 'junie'
+  | 'kilo'
+  | 'kimi-code-cli'
+  | 'kiro-cli'
+  | 'kode'
+  | 'lingma'
+  | 'loaf'
+  | 'mcpjam'
+  | 'mistral-vibe'
+  | 'moxby'
+  | 'mux'
+  | 'neovate'
+  | 'opencode'
+  | 'openhands'
+  | 'ona'
+  | 'pi'
+  | 'qoder'
+  | 'qoder-cn'
+  | 'qwen-code'
+  | 'replit'
+  | 'reasonix'
+  | 'roo'
+  | 'rovodev'
+  | 'tabnine-cli'
+  | 'terramind'
+  | 'tinycloud'
+  | 'trae'
+  | 'trae-cn'
+  | 'warp'
+  | 'windsurf'
+  | 'zed'
+  | 'zencoder'
+  | 'zenflow'
+  | 'pochi'
+  | 'promptscript'
+  | 'adal'
+  | 'universal';
+
+export interface Skill {
+  name: string;
+  description: string;
+  path: string;
+  /** Raw SKILL.md content for hashing */
+  rawContent?: string;
+  /** Name of the plugin this skill belongs to (if any) */
+  pluginName?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AgentConfig {
+  name: string;
+  displayName: string;
+  skillsDir: string;
+  /** Global skills directory. Set to undefined if the agent doesn't support global installation. */
+  globalSkillsDir: string | undefined;
+  detectInstalled: () => Promise<boolean>;
+  /** Whether to show this agent in the universal agents list. Defaults to true. */
+  showInUniversalList?: boolean;
+  /** Whether to display this universal agent in the interactive locked section. Defaults to true. */
+  showInUniversalPrompt?: boolean;
+}
+
+export interface ParsedSource {
+  type: 'github' | 'gitlab' | 'git' | 'local' | 'well-known';
+  url: string;
+  subpath?: string;
+  localPath?: string;
+  ref?: string;
+  /** Skill name extracted from @skill syntax (e.g., owner/repo@skill-name) */
+  skillFilter?: string;
+}
+
+/**
+ * Represents a skill fetched from a remote host provider.
+ */
+export interface RemoteSkill {
+  /** Display name of the skill (from frontmatter) */
+  name: string;
+  /** Description of the skill (from frontmatter) */
+  description: string;
+  /** Full markdown content including frontmatter */
+  content: string;
+  /** The identifier used for installation directory name */
+  installName: string;
+  /** The original source URL */
+  sourceUrl: string;
+  /** The provider that fetched this skill */
+  providerId: string;
+  /** Source identifier for telemetry (e.g., "mintlify.com") */
+  sourceIdentifier: string;
+  /** Any additional metadata from frontmatter */
+  metadata?: Record<string, unknown>;
+}

package/vendor/skills/src/update-source.ts

@@ -0,0 +1,90 @@
+export interface UpdateSourceEntry {
+  source: string;
+  sourceUrl: string;
+  ref?: string;
+  skillPath?: string;
+}
+
+export interface LocalUpdateSourceEntry {
+  source: string;
+  ref?: string;
+  skillPath?: string;
+}
+
+export function formatSourceInput(sourceUrl: string, ref?: string): string {
+  if (!ref) {
+    return sourceUrl;
+  }
+  return `${sourceUrl}#${ref}`;
+}
+
+/**
+ * Derive the skill's folder path from a SKILL.md-terminated skillPath.
+ * Returns '' when the skill lives at the repo root.
+ */
+function deriveSkillFolder(skillPath: string): string {
+  let folder = skillPath;
+  if (folder.endsWith('/SKILL.md')) {
+    folder = folder.slice(0, -9);
+  } else if (folder.endsWith('SKILL.md')) {
+    folder = folder.slice(0, -8);
+  }
+  if (folder.endsWith('/')) {
+    folder = folder.slice(0, -1);
+  }
+  return folder;
+}
+
+/**
+ * Whether a skill folder can be safely appended to the given source as a
+ * subpath. Only true for sources the source-parser can resolve as a
+ * GitHub/GitLab tree URL — owner/repo shorthand or an HTTPS URL on those
+ * hosts. Full SSH URLs (`git@host:owner/repo.git`) and generic Git URLs
+ * (anything ending in `.git`, or hosts other than github.com/gitlab.com)
+ * cannot have a subpath appended without producing an unclonable URL.
+ */
+function supportsAppendedSubpath(source: string): boolean {
+  if (source.startsWith('git@')) return false;
+  if (source.endsWith('.git')) return false;
+  if (source.startsWith('http://') || source.startsWith('https://')) {
+    try {
+      const host = new URL(source).hostname;
+      return host === 'github.com' || host === 'gitlab.com';
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+function appendFolderAndRef(source: string, skillPath: string, ref?: string): string {
+  if (!supportsAppendedSubpath(source)) {
+    return formatSourceInput(source, ref);
+  }
+  const folder = deriveSkillFolder(skillPath);
+  const withFolder = folder ? `${source}/${folder}` : source;
+  return ref ? `${withFolder}#${ref}` : withFolder;
+}
+
+/**
+ * Build the source argument for `skills add` during update.
+ * Uses shorthand form for path-targeted updates to avoid branch/path ambiguity.
+ */
+export function buildUpdateInstallSource(entry: UpdateSourceEntry): string {
+  if (!entry.skillPath) {
+    return formatSourceInput(entry.sourceUrl, entry.ref);
+  }
+  return appendFolderAndRef(entry.source, entry.skillPath, entry.ref);
+}
+
+/**
+ * Build the source argument for `skills add` during project-level update.
+ * Local lock entries don't carry `sourceUrl`, so we fall back to the bare
+ * `source` identifier when no `skillPath` is available.
+ */
+export function buildLocalUpdateSource(entry: LocalUpdateSourceEntry): string {
+  if (!entry.skillPath) {
+    return formatSourceInput(entry.source, entry.ref);
+  }
+  return appendFolderAndRef(entry.source, entry.skillPath, entry.ref);
+}