@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/cli/workspace-signals.js

@@ -0,0 +1,321 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { projectAiwgPath } from '../config/project-artifacts.js';
+const FRAMEWORKS = [
+    'sdlc',
+    'marketing',
+    'media-curator',
+    'research',
+    'forensics',
+    'security-engineering',
+    'ops',
+    'knowledge-base',
+];
+const ADDONS = [
+    'aiwg-utils',
+];
+const EXTENSIONS = [
+    'dev',
+    'it',
+    'net',
+    'sec',
+    'stream',
+    'sys',
+];
+const PROFILE_FRAMEWORKS = {
+    sdlc: ['sdlc'],
+    default: ['sdlc'],
+    marketing: ['marketing'],
+    'media-marketing': ['marketing'],
+    'media-curator': ['media-curator'],
+    research: ['research'],
+    forensics: ['forensics'],
+    'security-engineering': ['security-engineering'],
+    security: ['security-engineering'],
+    ops: ['ops'],
+    'knowledge-base': ['knowledge-base'],
+    kb: ['knowledge-base'],
+};
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJsonIfPresent(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === 'string') : [];
+}
+function addReason(included, id, reason) {
+    const reasons = included.get(id) ?? [];
+    if (!reasons.includes(reason))
+        reasons.push(reason);
+    included.set(id, reasons);
+}
+function includeProfile(included, profile, reason) {
+    const normalized = profile.toLowerCase();
+    if (normalized === 'all') {
+        for (const framework of FRAMEWORKS)
+            addReason(included, framework, reason);
+        return;
+    }
+    for (const framework of PROFILE_FRAMEWORKS[normalized] ?? []) {
+        addReason(included, framework, reason);
+    }
+}
+function extractConfigHints(config) {
+    if (!config)
+        return { bundles: [] };
+    const skillLoading = typeof config.skillLoading === 'object' && config.skillLoading
+        ? config.skillLoading
+        : {};
+    const profile = typeof config.workspaceProfile === 'string' ? config.workspaceProfile :
+        typeof config.profile === 'string' ? config.profile :
+            typeof skillLoading.profile === 'string' ? skillLoading.profile :
+                undefined;
+    const bundles = [
+        ...stringArray(config.enabledBundles),
+        ...stringArray(config.enabledSkills),
+        ...stringArray(skillLoading.include),
+        ...stringArray(skillLoading.bundles),
+    ];
+    return { profile, bundles };
+}
+async function detectIntakeProfiles(projectDir) {
+    const intakePath = projectAiwgPath(projectDir, 'intake', 'solution-profile.md');
+    try {
+        const content = (await fs.readFile(intakePath, 'utf-8')).toLowerCase();
+        const profiles = [];
+        if (content.includes('forensic') || content.includes('incident response'))
+            profiles.push('forensics');
+        if (content.includes('research') || content.includes('citation') || content.includes('literature'))
+            profiles.push('research');
+        if (content.includes('marketing') || content.includes('campaign') || content.includes('brand'))
+            profiles.push('marketing');
+        if (content.includes('media curator') || content.includes('discography') || content.includes('archive'))
+            profiles.push('media-curator');
+        if (content.includes('security') || content.includes('cryptograph') || content.includes('threat model'))
+            profiles.push('security-engineering');
+        if (content.includes('ops') || content.includes('runbook') || content.includes('infrastructure'))
+            profiles.push('ops');
+        if (content.includes('knowledge base') || content.includes('wiki') || content.includes('semantic memory'))
+            profiles.push('knowledge-base');
+        return profiles;
+    }
+    catch {
+        return [];
+    }
+}
+export async function resolveWorkspaceSignalPlan(projectDir, opts = {}) {
+    const included = new Map();
+    const signals = [];
+    const missedSignals = [];
+    const notes = [];
+    addReason(included, 'sdlc', 'always included as core lifecycle support');
+    addReason(included, 'aiwg-utils', 'always included as core AIWG utilities');
+    let profile = opts.profile;
+    let profileSource = profile ? 'flag' : 'auto';
+    const config = await readJsonIfPresent(projectAiwgPath(projectDir, 'aiwg.config'));
+    const configHints = extractConfigHints(config);
+    if (!profile && configHints.profile) {
+        profile = configHints.profile;
+        profileSource = 'config';
+    }
+    const requestedTarget = opts.requestedTarget;
+    if (!profile && requestedTarget && requestedTarget !== 'all' && !requestedTarget.startsWith('-')) {
+        profile = requestedTarget;
+        profileSource = 'requested-target';
+    }
+    if (profile) {
+        includeProfile(included, profile, `${profileSource} profile "${profile}"`);
+    }
+    for (const bundle of configHints.bundles) {
+        addReason(included, bundle, 'explicitly enabled in .aiwg/aiwg.config');
+    }
+    const domainSignals = [
+        ['forensics', '.aiwg/forensics/', 'forensics'],
+        ['research', '.aiwg/research/', 'research'],
+        ['marketing', '.aiwg/marketing/', 'marketing'],
+        ['media-curator', '.aiwg/media-curator/', 'media-curator'],
+        ['ops', '.aiwg/ops/', 'ops'],
+        ['knowledge-base', '.aiwg/knowledge-base/', 'knowledge-base'],
+        ['security-engineering', '.aiwg/security-engineering/', 'security-engineering'],
+    ];
+    for (const [framework, relPath, reasonPath] of domainSignals) {
+        const artifactPath = relPath.startsWith('.aiwg/')
+            ? projectAiwgPath(projectDir, relPath.slice('.aiwg/'.length))
+            : path.join(projectDir, relPath);
+        if (await exists(artifactPath)) {
+            signals.push(relPath);
+            addReason(included, framework, `matched ${reasonPath} workspace signal`);
+        }
+        else {
+            missedSignals.push(relPath);
+        }
+    }
+    if (await exists(path.join(projectDir, 'package.json')) && await exists(path.join(projectDir, 'src'))) {
+        signals.push('package.json + src/');
+        addReason(included, 'sdlc', 'matched application source workspace signal');
+    }
+    else {
+        missedSignals.push('package.json + src/');
+    }
+    const containerFiles = ['Dockerfile', 'compose.yaml', 'compose.yml', 'docker-compose.yaml', 'docker-compose.yml'];
+    const matchedContainer = [];
+    for (const file of containerFiles) {
+        if (await exists(path.join(projectDir, file)))
+            matchedContainer.push(file);
+    }
+    if (matchedContainer.length > 0) {
+        signals.push(matchedContainer.join(', '));
+        addReason(included, 'forensics', 'matched container workspace signal');
+        notes.push('Container signals currently map to the forensics framework; a narrower container skill subset can be layered on this plan later.');
+    }
+    else {
+        missedSignals.push('Dockerfile / compose.yaml');
+    }
+    const intakeProfiles = await detectIntakeProfiles(projectDir);
+    for (const intakeProfile of intakeProfiles) {
+        signals.push(`.aiwg/intake/solution-profile.md:${intakeProfile}`);
+        includeProfile(included, intakeProfile, `matched intake purpose "${intakeProfile}"`);
+    }
+    if (intakeProfiles.length === 0) {
+        missedSignals.push('.aiwg/intake/solution-profile.md');
+    }
+    if (included.has('security-engineering')) {
+        addReason(included, 'sdlc', 'dependency of security-engineering');
+    }
+    const bundles = [
+        ...FRAMEWORKS.map((id) => ({
+            type: 'framework',
+            id,
+            included: included.has(id),
+            reasons: included.get(id) ?? ['no matching workspace signal'],
+        })),
+        ...ADDONS.map((id) => ({
+            type: 'addon',
+            id,
+            included: included.has(id),
+            reasons: included.get(id) ?? ['no matching workspace signal'],
+        })),
+        ...EXTENSIONS.map((id) => ({
+            type: 'extension',
+            id,
+            included: included.has(id),
+            reasons: included.get(id) ?? ['no matching workspace signal'],
+        })),
+    ];
+    return {
+        projectDir,
+        generatedAt: new Date().toISOString(),
+        profile: profile ?? 'auto',
+        profileSource,
+        requestedTarget,
+        signals,
+        missedSignals,
+        bundles,
+        notes,
+    };
+}
+export async function writeWorkspaceSignalPlan(projectDir, plan) {
+    const planPath = projectAiwgPath(projectDir, 'workspace-skill-plan.json');
+    await fs.mkdir(path.dirname(planPath), { recursive: true });
+    await fs.writeFile(planPath, JSON.stringify(plan, null, 2) + '\n', 'utf-8');
+    return planPath;
+}
+export async function readWorkspaceSignalPlan(projectDir) {
+    try {
+        const content = await fs.readFile(projectAiwgPath(projectDir, 'workspace-skill-plan.json'), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function includedBundleIds(plan, type) {
+    return plan.bundles
+        .filter((bundle) => bundle.type === type && bundle.included)
+        .map((bundle) => bundle.id);
+}
+function formatBundleGroup(plan, included, type) {
+    return plan.bundles
+        .filter((bundle) => bundle.type === type && bundle.included === included)
+        .map((bundle) => `  - ${bundle.id}: ${bundle.reasons.join('; ')}`);
+}
+export function formatWorkspaceSignalPlan(plan) {
+    const lines = [];
+    lines.push('Workspace skill loading plan (dry run)');
+    lines.push(`Project: ${plan.projectDir}`);
+    lines.push(`Profile: ${plan.profile} (${plan.profileSource})`);
+    if (plan.requestedTarget)
+        lines.push(`Requested target: ${plan.requestedTarget}`);
+    lines.push('');
+    lines.push('Included');
+    for (const type of ['framework', 'addon', 'extension']) {
+        const rows = formatBundleGroup(plan, true, type);
+        if (rows.length > 0) {
+            lines.push(`${type}s:`);
+            lines.push(...rows);
+        }
+    }
+    lines.push('');
+    lines.push('Excluded');
+    for (const type of ['framework', 'addon', 'extension']) {
+        const rows = formatBundleGroup(plan, false, type);
+        if (rows.length > 0) {
+            lines.push(`${type}s:`);
+            lines.push(...rows);
+        }
+    }
+    lines.push('');
+    lines.push('Signals matched:');
+    if (plan.signals.length === 0) {
+        lines.push('  - none');
+    }
+    else {
+        for (const signal of plan.signals)
+            lines.push(`  - ${signal}`);
+    }
+    lines.push('');
+    lines.push('Signals not present:');
+    for (const signal of plan.missedSignals)
+        lines.push(`  - ${signal}`);
+    if (plan.notes.length > 0) {
+        lines.push('');
+        lines.push('Notes:');
+        for (const note of plan.notes)
+            lines.push(`  - ${note}`);
+    }
+    lines.push('');
+    lines.push('No files were changed. Run `aiwg use --profile <name>` to deploy a workspace-aware subset, or `aiwg use all` for the full deployment.');
+    return lines.join('\n');
+}
+export function formatDeployedWorkspaceSignalPlan(plan) {
+    const lines = [];
+    lines.push(`\nWorkspace skill filter: ${plan.profile} (${plan.profileSource})`);
+    if (plan.generatedAt)
+        lines.push(`Resolved: ${plan.generatedAt}`);
+    lines.push('Included:');
+    const included = plan.bundles.filter((bundle) => bundle.included);
+    for (const bundle of included) {
+        lines.push(`  ${bundle.type}/${bundle.id}: ${bundle.reasons.join('; ')}`);
+    }
+    lines.push('Filtered out:');
+    const excluded = plan.bundles.filter((bundle) => !bundle.included);
+    for (const bundle of excluded) {
+        lines.push(`  ${bundle.type}/${bundle.id}: ${bundle.reasons.join('; ')}`);
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=workspace-signals.js.map

package/dist/src/community/footer.js

@@ -0,0 +1,14 @@
+import { formatCommunityFooter } from './links.js';
+import { markNudgeShown, shouldShowNudge } from './nudge-policy.js';
+export function maybePrintCommunityFooter() {
+    if (!shouldShowNudge('discovery-footer'))
+        return false;
+    const footer = formatCommunityFooter();
+    if (!footer)
+        return false;
+    console.log('');
+    console.log(footer);
+    markNudgeShown('discovery-footer');
+    return true;
+}
+//# sourceMappingURL=footer.js.map

package/dist/src/community/links.js

@@ -0,0 +1,123 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { parse } from 'yaml';
+const EMPTY_LINKS = {
+    website: '',
+    repository: { github: '' },
+    channels: [],
+    star_cta: { short: '', long: '' },
+};
+function moduleDir() {
+    return path.dirname(fileURLToPath(import.meta.url));
+}
+export function communityDataPath() {
+    return path.resolve(moduleDir(), '..', 'data', 'community.yaml');
+}
+function isString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function validateCommunityLinks(raw) {
+    const issues = [];
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return ['community links must be an object'];
+    }
+    const data = raw;
+    if (!isString(data.website))
+        issues.push('website must be a non-empty string');
+    const repository = data.repository;
+    if (!repository || typeof repository !== 'object' || Array.isArray(repository)) {
+        issues.push('repository must be an object');
+    }
+    else if (!isString(repository.github)) {
+        issues.push('repository.github must be a non-empty string');
+    }
+    if (!Array.isArray(data.channels)) {
+        issues.push('channels must be an array');
+    }
+    else {
+        for (const [index, channel] of data.channels.entries()) {
+            if (!channel || typeof channel !== 'object' || Array.isArray(channel)) {
+                issues.push(`channels[${index}] must be an object`);
+                continue;
+            }
+            const ch = channel;
+            for (const key of ['id', 'name', 'url', 'cta']) {
+                if (!isString(ch[key]))
+                    issues.push(`channels[${index}].${key} must be a non-empty string`);
+            }
+        }
+    }
+    const starCta = data.star_cta;
+    if (!starCta || typeof starCta !== 'object' || Array.isArray(starCta)) {
+        issues.push('star_cta must be an object');
+    }
+    else {
+        const cta = starCta;
+        if (!isString(cta.short))
+            issues.push('star_cta.short must be a non-empty string');
+        if (!isString(cta.long))
+            issues.push('star_cta.long must be a non-empty string');
+    }
+    return issues;
+}
+export function loadCommunityLinks(opts = {}) {
+    const dataPath = opts.dataPath ?? communityDataPath();
+    try {
+        if (!existsSync(dataPath)) {
+            opts.warn?.(`Community links file not found: ${dataPath}`);
+            return { ...EMPTY_LINKS, channels: [] };
+        }
+        const parsed = parse(readFileSync(dataPath, 'utf8'));
+        const issues = validateCommunityLinks(parsed);
+        if (issues.length > 0) {
+            opts.warn?.(`Community links file is invalid: ${issues.join('; ')}`);
+            return { ...EMPTY_LINKS, channels: [] };
+        }
+        return parsed;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        opts.warn?.(`Failed to load community links: ${msg}`);
+        return { ...EMPTY_LINKS, channels: [] };
+    }
+}
+export function compactUrl(url) {
+    return url.replace(/^https?:\/\//, '').replace(/\/$/, '');
+}
+export function formatCommunityFooter(links = loadCommunityLinks()) {
+    const parts = [
+        links.repository.github ? compactUrl(links.repository.github) : '',
+        links.channels.find((ch) => ch.id === 'discord')?.url
+            ? compactUrl(links.channels.find((ch) => ch.id === 'discord').url)
+            : '',
+        links.website ? compactUrl(links.website) : '',
+    ].filter(Boolean);
+    return parts.length > 0 ? `Community: ${parts.join(' · ')}` : null;
+}
+export function formatStarNudge(links = loadCommunityLinks()) {
+    if (!links.star_cta.long)
+        return null;
+    return `${links.star_cta.long}\nHide this: aiwg config set --user community.nudges false`;
+}
+export function formatMilestoneCelebration(milestone, links = loadCommunityLinks()) {
+    const repo = links.repository.github ? compactUrl(links.repository.github) : '';
+    const discord = links.channels.find((ch) => ch.id === 'discord')?.url ?? '';
+    const discordCompact = discord ? compactUrl(discord) : '';
+    if (!repo && !discordCompact)
+        return null;
+    const titles = {
+        first_deploy: 'First AIWG deploy complete.',
+        first_phase_transition: 'First phase transition complete.',
+        first_release: 'First release complete.',
+        first_production_deploy: 'First production deploy complete.',
+    };
+    const lines = [titles[milestone] ?? 'AIWG milestone complete.'];
+    if (repo)
+        lines.push(`If AIWG helped get you here, a star at ${repo} helps others find it.`);
+    if (discordCompact)
+        lines.push(`Share what you built: ${discordCompact}`);
+    lines.push('Hide future nudges: aiwg config set --user community.nudges false');
+    return lines.join('\n');
+}
+//# sourceMappingURL=links.js.map

package/dist/src/community/milestones.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import path from 'path';
+import { formatMilestoneCelebration } from './links.js';
+import { shouldShowNudge } from './nudge-policy.js';
+import { projectAiwgPath } from '../config/project-artifacts.js';
+export function milestoneStatePath(projectDir) {
+    return projectAiwgPath(projectDir, '.milestones.json');
+}
+function readMilestones(projectDir) {
+    const statePath = milestoneStatePath(projectDir);
+    if (!existsSync(statePath))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(statePath, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function recordMilestone(projectDir, milestone, now = new Date()) {
+    const state = readMilestones(projectDir);
+    if (state[milestone])
+        return false;
+    state[milestone] = now.toISOString();
+    const statePath = milestoneStatePath(projectDir);
+    mkdirSync(path.dirname(statePath), { recursive: true });
+    writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+    return true;
+}
+export function maybeCelebrateMilestone(projectDir, milestone) {
+    if (!shouldShowNudge('milestone'))
+        return false;
+    const isFirst = recordMilestone(projectDir, milestone);
+    if (!isFirst)
+        return false;
+    const message = formatMilestoneCelebration(milestone);
+    if (!message)
+        return false;
+    console.log('');
+    console.log(message);
+    return true;
+}
+//# sourceMappingURL=milestones.js.map

package/dist/src/community/nudge-policy.js

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { parseYamlSimple } from '../config/user-config.js';
+const DAY_MS = 24 * 60 * 60 * 1000;
+const CONTEXT_KEYS = {
+    intake: 'intake-shown',
+    'discovery-footer': 'footer-shown',
+};
+const CONTEXT_TTL_MS = {
+    intake: 90 * DAY_MS,
+    'discovery-footer': 7 * DAY_MS,
+};
+export function userAiwgDir() {
+    return process.env.AIWG_CONFIG ? path.resolve(process.env.AIWG_CONFIG) : path.join(os.homedir(), '.aiwg');
+}
+export function nudgeStatePath() {
+    return path.join(userAiwgDir(), '.nudge-state.json');
+}
+function envSuppresses() {
+    const noNudge = process.env.AIWG_NO_NUDGE?.toLowerCase();
+    if (noNudge === '1' || noNudge === 'true' || noNudge === 'yes')
+        return true;
+    if (process.env.CI?.toLowerCase() === 'true' || process.env.CI === '1')
+        return true;
+    return false;
+}
+function userConfigSuppresses() {
+    const configPath = path.join(userAiwgDir(), 'config.yaml');
+    if (!existsSync(configPath))
+        return false;
+    try {
+        const parsed = parseYamlSimple(readFileSync(configPath, 'utf8'));
+        const community = parsed.community;
+        return Boolean(community &&
+            typeof community === 'object' &&
+            !Array.isArray(community) &&
+            community.nudges === false);
+    }
+    catch {
+        return false;
+    }
+}
+function stdoutIsTty() {
+    return Boolean(process.stdout.isTTY);
+}
+function readState() {
+    const statePath = nudgeStatePath();
+    if (!existsSync(statePath))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(statePath, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function isWithinThrottle(key, ttlMs, now) {
+    const state = readState();
+    const raw = state[key];
+    if (!raw)
+        return false;
+    const then = new Date(raw);
+    if (Number.isNaN(then.getTime()))
+        return false;
+    return now.getTime() - then.getTime() < ttlMs;
+}
+export function shouldShowNudge(ctx, opts = {}) {
+    if (envSuppresses())
+        return false;
+    if (userConfigSuppresses())
+        return false;
+    if (opts.requireTty ?? true) {
+        if (!stdoutIsTty())
+            return false;
+    }
+    if (ctx === 'milestone')
+        return true;
+    const key = CONTEXT_KEYS[ctx];
+    const ttlMs = CONTEXT_TTL_MS[ctx];
+    return !isWithinThrottle(key, ttlMs, opts.now ?? new Date());
+}
+export function markNudgeShown(ctx, opts = {}) {
+    const statePath = nudgeStatePath();
+    const state = readState();
+    state[CONTEXT_KEYS[ctx]] = (opts.now ?? new Date()).toISOString();
+    mkdirSync(path.dirname(statePath), { recursive: true });
+    writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+//# sourceMappingURL=nudge-policy.js.map