Environment API

// Trigger a background rescan on chat session activation
const { scanned }: { scanned: boolean } = await fetch('/api/environment/rescan-if-stale', {
method: 'POST',
}).then((r: Response) => r.json());

if (scanned) {
console.log('Background rescan triggered — environment data will refresh shortly');
} else {
console.log('Scan is fresh — no rescan needed');
}

// Scan a project directory to discover its environment
interface ScanResult {
scan: { id: string };
summary: {
  totalArtifacts: number;
  personas: string[];
  categoryCounts: Record<string, number>;
  durationMs: number;
};
}

const { scan, summary }: ScanResult = await fetch('/api/environment/scan', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  projectDir: '/Users/team/my-app',
  projectId: 'proj-8f3a-4b2c',
}),
}).then((r: Response) => r.json());

console.log(`Scan ${scan.id}: ${summary.totalArtifacts} artifacts in ${summary.durationMs}ms`);
console.log(`Personas: ${summary.personas.join(', ')}`);
console.log(`Categories: ${JSON.stringify(summary.categoryCounts)}`);

// Get the latest scan, auto-refresh if stale
const { scan, summary }: {
scan: { createdAt: string } | null;
summary: { categoryCounts: Record<string, number> };
} = await fetch('/api/environment/scan?projectId=proj-8f3a-4b2c')
.then((r: Response) => r.json());

if (scan) {
console.log(`Last scanned: ${scan.createdAt}`);
console.log(`Artifacts: ${JSON.stringify(summary.categoryCounts)}`);
} else {
console.log('No scan found — trigger one with POST /api/environment/scan');
}

// List Node.js config artifacts
interface Artifact {
name: string;
filePath: string;
}

const { artifacts, count }: { artifacts: Artifact[]; count: number } =
await fetch('/api/environment/artifacts?category=config&tool=node')
  .then((r: Response) => r.json());

console.log(`${count} Node.js config artifacts:`);
artifacts.forEach((a: Artifact) => console.log(`  ${a.name} — ${a.filePath}`));

const { artifact }: { artifact: { name: string; tool: string; filePath: string } } =
await fetch('/api/environment/artifacts/art-5e6f-7g8h').then((r: Response) => r.json());
console.log(`${artifact.name} (${artifact.tool}) at ${artifact.filePath}`);

// List all skills enriched with environment context
interface EnrichedSkill {
id: string;
name: string;
description: string;
filePath: string;
scope: string;
}

const skills: EnrichedSkill[] = await fetch('/api/environment/skills')
.then((r: Response) => r.json());

console.log(`${skills.length} skills in environment:`);
skills.forEach((s: EnrichedSkill) => {
console.log(`  ${s.name} [${s.scope}] — ${s.filePath}`);
});

// List checkpoints for a project
interface Checkpoint {
label: string;
status: string;
filesCount: number;
createdAt: string;
}

const { checkpoints }: { checkpoints: Checkpoint[] } =
await fetch('/api/environment/checkpoints?projectId=proj-8f3a-4b2c')
  .then((r: Response) => r.json());

checkpoints.forEach((cp: Checkpoint) => {
console.log(`${cp.label} [${cp.status}] — ${cp.filesCount} files — ${cp.createdAt}`);
});

// Create a manual checkpoint before risky changes
interface CheckpointResponse {
checkpoint: {
  id: string;
  filesCount: number;
  gitTag?: string;
  gitCommitSha?: string;
};
}

const { checkpoint }: CheckpointResponse = await fetch('/api/environment/checkpoints', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  label: 'Before dependency upgrade',
  projectDir: '/Users/team/my-app',
}),
}).then((r: Response) => r.json());

console.log(`Checkpoint ${checkpoint.id}: ${checkpoint.filesCount} files captured`);
if (checkpoint.gitTag) {
console.log(`Git tag: ${checkpoint.gitTag} (${checkpoint.gitCommitSha})`);
}

// Review changes since checkpoint
const { checkpoint, syncOps, diff }: {
checkpoint: { label: string; status: string };
syncOps: unknown[];
diff: string | null;
} = await fetch('/api/environment/checkpoints/cp-4d5e-6f7g')
.then((r: Response) => r.json());

console.log(`${checkpoint.label} [${checkpoint.status}]`);
console.log(`${syncOps.length} sync operations`);
if (diff) {
console.log(`Git changes since checkpoint:\n${diff}`);
}

// Rollback to a checkpoint
interface RollbackResult {
message: string;
results: {
  git?: { success: boolean; error?: string };
  backup?: { restored: number };
};
}

const result: RollbackResult = await fetch('/api/environment/checkpoints/cp-4d5e-6f7g', {
method: 'POST',
}).then((r: Response) => r.json());

console.log(result.message);
if (result.results.git) {
console.log(`Git rollback: ${result.results.git.success ? 'OK' : result.results.git.error}`);
}
if (result.results.backup) {
console.log(`Restored ${result.results.backup.restored} files`);
}

// Get tiered profile suggestions
interface Suggestion {
name: string;
description: string;
}

const { curated, discovered }: { curated: Suggestion[]; discovered: Suggestion[] } =
await fetch('/api/environment/profiles/suggest?tiered=true')
  .then((r: Response) => r.json());

console.log('Recommended profiles:');
curated.forEach((s: Suggestion) => console.log(`  [curated] ${s.name} — ${s.description}`));
discovered.forEach((s: Suggestion) => console.log(`  [discovered] ${s.name} — ${s.description}`));

// Create a profile from the top curated suggestion
const profile: { message: string; profileId: string } = await fetch('/api/environment/profiles/create', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  suggestion: curated[0],
  overrides: { name: 'My Node Profile' },
}),
}).then((r: Response) => r.json());

console.log(`Profile created: ${profile.profileId}`);

// Preview what would change before applying
interface PreviewResult {
previews: unknown[];
summary: {
  total: number;
  conflicts: number;
  totalAdditions: number;
  totalDeletions: number;
};
}

const preview: PreviewResult = await fetch('/api/environment/sync/preview', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  operations: [
    { targetPath: '.prettierrc', content: '{ "semi": false, "singleQuote": true }' },
  ],
}),
}).then((r: Response) => r.json());

console.log(`${preview.summary.total} operations, ${preview.summary.conflicts} conflicts`);
console.log(`+${preview.summary.totalAdditions} / -${preview.summary.totalDeletions} lines`);

// Sync config files (automatic checkpoint created for safety)
interface SyncResult {
checkpointId: string;
summary: { applied: number; failed: number };
}

const result: SyncResult = await fetch('/api/environment/sync', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  operations: [
    { targetPath: '.prettierrc', content: '{ "semi": false, "singleQuote": true }' },
  ],
  label: 'Apply prettier config',
}),
}).then((r: Response) => r.json());

console.log(`Checkpoint: ${result.checkpointId}`);
console.log(`Applied: ${result.summary.applied}, Failed: ${result.summary.failed}`);

// Review recent sync history
interface SyncHistoryEntry {
checkpoint: { label: string; createdAt: string };
operations: unknown[];
}

const { history }: { history: SyncHistoryEntry[] } =
await fetch('/api/environment/sync/history?limit=5').then((r: Response) => r.json());

history.forEach((entry: SyncHistoryEntry) => {
console.log(`${entry.checkpoint.label} — ${entry.operations.length} ops — ${entry.checkpoint.createdAt}`);
});

// List available environment templates
interface Template {
name: string;
description: string;
}

const { templates }: { templates: Template[] } =
await fetch('/api/environment/templates').then((r: Response) => r.json());
templates.forEach((t: Template) => console.log(`${t.name} — ${t.description}`));

// Capture the current environment as a template
const { template }: { template: { id: string } } = await fetch('/api/environment/templates', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
  scanId: 'scan-1a2b-3c4d',
  name: 'Next.js Starter',
  description: 'Next.js 15 + TypeScript + Tailwind baseline configuration',
}),
}).then((r: Response) => r.json());

console.log(`Template saved: ${template.id}`);

const { template, manifest }: {
template: { name: string };
manifest: { artifacts: unknown[] };
} = await fetch('/api/environment/templates/tpl-1a2b-3c4d')
.then((r: Response) => r.json());
console.log(`${template.name}: ${manifest.artifacts.length} artifacts`);

await fetch('/api/environment/templates/tpl-1a2b-3c4d', { method: 'DELETE' });