Profiles API

// List profiles and filter by runtime compatibility
const profiles: Profile[] = await fetch('/api/profiles?scope=all&projectId=proj-8f3a-4b2c')
.then(r => r.json());

// Group by scope for display
const grouped = Object.groupBy(profiles, p => p.scope);
for (const [scope, items] of Object.entries(grouped)) {
console.log(`${scope} (${items.length}):`);
items.forEach(p => console.log(`  ${p.name} — ${p.description}`));
}

// Create a profile with smoke tests for verification
const res: Response = await fetch('/api/profiles', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  id: 'security-reviewer',
  name: 'Security Reviewer',
  version: '1.0.0',
  domain: 'work',
  tags: ['security', 'code-review', 'owasp'],
  skillMd: 'You are a security-focused code reviewer. Check every change against the OWASP Top 10. Flag SQL injection, XSS, CSRF, and auth bypass risks. Always suggest remediations.',
  supportedRuntimes: ['claude-code', 'anthropic-direct'],
  tests: [
    {
      task: 'Review this code for SQL injection: db.query("SELECT * FROM users WHERE id = " + userId)',
      expectedKeywords: ['SQL injection', 'parameterized', 'prepared statement'],
    },
  ],
}),
});

if (res.status === 201) {
console.log('Profile created — run /test to verify behavior');
}

// Fetch the full profile including SKILL.md content
const profile: Profile = await fetch('/api/profiles/security-reviewer')
.then(r => r.json());

console.log(`${profile.name} v${profile.version} [${profile.scope}]`);
console.log(`Runtimes: ${profile.supportedRuntimes.join(', ')}`);
console.log(`SKILL.md: ${profile.skillMd.substring(0, 100)}...`);

// Update the profile and bump version
await fetch('/api/profiles/security-reviewer', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  id: 'security-reviewer',
  name: 'Security Reviewer',
  version: '1.1.0',
  domain: 'work',
  tags: ['security', 'code-review', 'owasp', 'sast'],
  skillMd: 'You are a senior security reviewer. Check all changes against OWASP Top 10 and CWE Top 25...',
}),
});

// Delete a user profile — built-ins and project profiles are protected
const res: Response = await fetch('/api/profiles/security-reviewer', { method: 'DELETE' });

if (res.status === 403) {
console.log('Cannot delete built-in or project-scoped profiles');
}

// Run all profile tests and report results
const report: TestReport = await fetch('/api/profiles/security-reviewer/test', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ runtimeId: 'claude-code' }),
}).then(r => r.json());

console.log(`${report.passed}/${report.total} tests passed`);
report.results.forEach(t => {
console.log(`  [${t.pass ? 'PASS' : 'FAIL'}] ${t.task.substring(0, 60)}...`);
});

// Run tests one by one for real-time progress display
const profile: Profile = await fetch('/api/profiles/security-reviewer').then(r => r.json());
const testCount: number = profile.tests?.length ?? 0;

for (let i = 0; i < testCount; i++) {
console.log(`Running test ${i + 1}/${testCount}...`);

const result: TestResult = await fetch('/api/profiles/security-reviewer/test-single', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ testIndex: i, runtimeId: 'claude-code' }),
}).then(r => r.json());

console.log(`  [${result.pass ? 'PASS' : 'FAIL'}] ${result.durationMs}ms`);
}

// Check saved test results without re-running tests
const results: TestReport = await fetch(
'/api/profiles/security-reviewer/test-results?runtimeId=claude-code'
).then(r => r.json());

console.log(`Last tested: ${results.passed}/${results.total} passed`);

// Check learned context size and version history
const ctx: ContextInfo = await fetch('/api/profiles/data-analyst/context')
.then(r => r.json());

const pct: string = ((ctx.currentSize / ctx.maxSize) * 100).toFixed(1);
console.log(`Context: ${ctx.currentSize} / ${ctx.maxSize} bytes (${pct}%)`);
console.log(`Versions: ${ctx.history.length}`);

// Inject context manually — creates a new version
await fetch('/api/profiles/data-analyst/context', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  additions: 'Always use pandas for CSV processing. Prefer seaborn for visualizations. Include confidence intervals in statistical reports.',
}),
});

// Approve a pending context proposal from the agent
await fetch('/api/profiles/data-analyst/context', {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  action: 'approve',
  notificationId: 'notif-ctx-789',
}),
});

// Or rollback to a previous version if the latest context is wrong
await fetch('/api/profiles/data-analyst/context', {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  action: 'rollback',
  targetVersion: 2,
}),
});

// Generate a new profile from a natural language goal
const generated: GeneratedProfile = await fetch('/api/profiles/assist', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  goal: 'A profile that reviews pull requests for security issues, focusing on OWASP Top 10 and input validation',
  domain: 'work',
  mode: 'generate',
}),
}).then(r => r.json());

console.log(`Suggested name: ${generated.name}`);
console.log(`Tags: ${generated.tags.join(', ')}`);
console.log(`SKILL.md preview: ${generated.skillMd.substring(0, 200)}...`);

// Use the generated config to create the profile
await fetch('/api/profiles', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(generated),
});

// Import a profile from GitHub
const { id, name }: { id: string; name: string } = await fetch('/api/profiles/import', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  url: 'https://github.com/acme/ainative-profiles/tree/main/.claude/skills/security-reviewer',
}),
}).then(r => r.json());

console.log(`Imported "${name}" as ${id}`);

// List all repository imports
const imports: RepoImport[] = await fetch('/api/profiles/import-repo')
.then(r => r.json());

imports.forEach(i => {
console.log(`${i.url} → ${i.profileIds.join(', ')}`);
});

// Step 1: Scan a GitHub repository for importable skills
interface DiscoveredSkill {
path: string;
name: string;
format: 'ainative-business' | 'skill-md-only';
}
interface ScanResult {
owner: string;
repo: string;
branch: string;
commitSha: string;
repoUrl: string;
skills: DiscoveredSkill[];
}

const scan: ScanResult = await fetch('/api/profiles/import-repo/scan', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  url: 'https://github.com/acme/ainative-skills',
}),
}).then(r => r.json());

console.log(`Found ${scan.skills.length} skills in ${scan.owner}/${scan.repo}@${scan.branch}`);
scan.skills.forEach(s => console.log(`  ${s.name} (${s.format}) — ${s.path}`));

// Step 2: Preview selected skills with dedup detection
interface Preview {
skill: { name: string; path: string };
config: { id: string; name: string } | null;
dedup: { status: string; similarity?: number; matchedProfileId?: string } | null;
error: string | null;
}

const { previews }: { previews: Preview[] } = await fetch('/api/profiles/import-repo/preview', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  owner: scan.owner,
  repo: scan.repo,
  branch: scan.branch,
  commitSha: scan.commitSha,
  repoUrl: scan.repoUrl,
  skills: scan.skills,
}),
}).then(r => r.json());

previews.forEach(p => {
if (p.error) {
  console.log(`  [ERROR] ${p.skill.name}: ${p.error}`);
} else if (p.dedup?.status === 'duplicate') {
  console.log(`  [SKIP] ${p.config?.id} — duplicate of ${p.dedup.matchedProfileId}`);
} else if (p.dedup?.status === 'similar') {
  console.log(`  [WARN] ${p.config?.id} — ${p.dedup.similarity?.toFixed(0)}% similar to ${p.dedup.matchedProfileId}`);
} else {
  console.log(`  [NEW] ${p.config?.id}`);
}
});

// Step 3: Confirm the import with per-profile actions
interface ImportResult {
ok: boolean;
imported: number;
replaced: number;
skipped: number;
profileIds: string[];
errors?: string[];
}

const result: ImportResult = await fetch('/api/profiles/import-repo/confirm', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  repoUrl: 'https://github.com/acme/ainative-skills',
  owner: 'acme',
  repo: 'ainative-skills',
  branch: 'main',
  commitSha: 'a1b2c3d4e5f6789012345678901234567890abcd',
  imports: previews
    .filter(p => p.config && !p.error)
    .map(p => ({
      config: p.config,
      skillMd: p.skillMd,
      // Skip duplicates, replace similar, import new
      action: p.dedup?.status === 'duplicate' ? 'skip'
            : p.dedup?.status === 'similar'    ? 'replace'
            : 'import',
    })),
}),
}).then(r => r.json());

console.log(`Imported: ${result.imported}, Replaced: ${result.replaced}, Skipped: ${result.skipped}`);
console.log(`Profile IDs: ${result.profileIds.join(', ')}`);
if (result.errors?.length) {
console.error(`Errors: ${result.errors.join(', ')}`);
}

// Step 4: Check if any imported profiles have updates available
interface UpdateCheck {
profileId: string;
profileName: string;
localHash: string;
remoteHash: string;
hasUpdate: boolean;
}

const { hasUpdates, updates }: { hasUpdates: boolean; updates: UpdateCheck[] } =
await fetch('/api/profiles/import-repo/check-updates', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ repoImportId: 'reimport-uuid-here' }),
}).then(r => r.json());

if (!hasUpdates) {
console.log('All profiles are up to date');
} else {
updates.filter(u => u.hasUpdate).forEach(u => {
  console.log(`${u.profileName} — update available`);
  console.log(`  Local:  ${u.localHash}`);
  console.log(`  Remote: ${u.remoteHash}`);
});
}

// Step 5: Apply accepted updates, skip declined ones
interface ApplyResult {
ok: boolean;
applied: number;
skipped: number;
errors?: string[];
}

// Only apply updates for profiles where hasUpdate is true
const updateDecisions = updates.map(u => ({
profileId: u.profileId,
accept: u.hasUpdate,  // accept available updates, skip unchanged
}));

const result: ApplyResult = await fetch('/api/profiles/import-repo/apply-updates', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ updates: updateDecisions }),
}).then(r => r.json());

console.log(`Applied: ${result.applied}, Skipped: ${result.skipped}`);
if (result.errors?.length) {
console.error(`Errors: ${result.errors.join(', ')}`);
}