aman-intelligence 0.1.0

package/dist/ui/components/Narrator.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+import { Spinner } from '../animations/Spinner.js';
+import { SuccessIndicator } from '../animations/SuccessIndicator.js';
+import { ErrorIndicator } from '../animations/ErrorIndicator.js';
+import { SyncActivity } from '../animations/SyncActivity.js';
+export const Narrator = ({ state, message, compact = false }) => {
+    const text = message || '';
+    return (_jsx(Box, { marginRight: compact ? 1 : 0, children: (() => {
+            switch (state) {
+                case 'syncing':
+                    return _jsx(SyncActivity, { label: text });
+                case 'success':
+                    return _jsx(SuccessIndicator, { message: text });
+                case 'error':
+                    return _jsx(ErrorIndicator, { message: text });
+                case 'searching':
+                case 'installing':
+                case 'updating':
+                    return _jsx(Spinner, { label: text });
+                default:
+                    return (_jsxs(Text, { color: theme.dim, children: [_jsx(Text, { bold: true, children: "\u00B7" }), text ? ` ${text}` : ''] }));
+            }
+        })() }));
+};

package/dist/ui/components/ScopePrompt.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { Scope } from '../../types/index.js';
+interface ScopePromptProps {
+    label?: string;
+    onSelect: (scope: Scope) => void;
+}
+export declare const ScopePrompt: React.FC<ScopePromptProps>;
+export {};

package/dist/ui/components/ScopePrompt.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { CustomSelectInput } from './CustomSelect.js';
+import { theme } from '../theme.js';
+import { exists } from '../../storage/filesystem.js';
+import path from 'path';
+const scopeItems = [
+    { label: 'Project', value: 'project' },
+    { label: 'Global', value: 'global' },
+];
+const scopeItemsGlobalFirst = [
+    { label: 'Global', value: 'global' },
+    { label: 'Project', value: 'project' },
+];
+function isInsideProject() {
+    // Check if .aman/ or package.json exists in cwd
+    return exists(path.resolve(process.cwd(), '.aman')) || exists(path.resolve(process.cwd(), 'package.json'));
+}
+export const ScopePrompt = ({ label = 'Install location', onSelect }) => {
+    const inProject = isInsideProject();
+    const items = inProject ? scopeItems : scopeItemsGlobalFirst;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.dim, children: label }), _jsx(Box, { marginTop: 0, children: _jsx(CustomSelectInput, { items: items, onSelect: (item) => onSelect(item.value) }) })] }));
+};

package/dist/ui/components/TooSmallScreen.d.ts

@@ -0,0 +1,8 @@
+interface TooSmallScreenProps {
+    columns: number;
+    rows: number;
+    minColumns: number;
+    minRows: number;
+}
+export declare const TooSmallScreen: ({ columns, rows, minColumns, minRows, }: TooSmallScreenProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/components/TooSmallScreen.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+export const TooSmallScreen = ({ columns, rows, minColumns, minRows, }) => {
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: theme.error, children: "Terminal too small" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: ["Current: ", columns, "\u00D7", rows] }), _jsxs(Text, { children: ["Required: ", minColumns, "\u00D7", minRows] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.primary, children: "Please enlarge the terminal." }) })] }));
+};

package/dist/ui/date.d.ts

@@ -0,0 +1,2 @@
+export declare function getRelativeBackupDate(backupName: string): string;
+export declare function getBackupLabel(backupName: string): string;

package/dist/ui/date.js

@@ -0,0 +1,33 @@
+export function getRelativeBackupDate(backupName) {
+    if (!backupName || backupName === 'none' || backupName === 'never')
+        return 'Never';
+    const match = backupName.match(/^(\d{4})-(\d{2})-(\d{2})/);
+    if (!match)
+        return 'Never';
+    const year = parseInt(match[1], 10);
+    const month = parseInt(match[2], 10) - 1; // 0-indexed month
+    const day = parseInt(match[3], 10);
+    const dateObj = new Date(year, month, day);
+    if (isNaN(dateObj.getTime()))
+        return 'Never';
+    const now = new Date();
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const backup = new Date(dateObj.getFullYear(), dateObj.getMonth(), dateObj.getDate());
+    const diffTime = today.getTime() - backup.getTime();
+    const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
+    if (diffDays === 0)
+        return 'Today';
+    if (diffDays === 1)
+        return 'Yesterday';
+    if (diffDays > 1)
+        return `${diffDays} days ago`;
+    return 'Today';
+}
+export function getBackupLabel(backupName) {
+    const relative = getRelativeBackupDate(backupName);
+    if (relative === 'Never')
+        return backupName;
+    const labelIndex = backupName.indexOf('Z-');
+    const labelText = labelIndex !== -1 ? backupName.substring(labelIndex + 2) : backupName;
+    return `${relative} (${labelText})`;
+}

package/dist/ui/layout.d.ts

@@ -0,0 +1,23 @@
+export interface StdoutDimensions {
+    columns: number;
+    rows: number;
+}
+export declare function useStdoutDimensions(): StdoutDimensions;
+export interface ResponsiveLayout {
+    columns: number;
+    rows: number;
+    physicalColumns: number;
+    physicalRows: number;
+    isTooSmall: boolean;
+    isCompact: boolean;
+    canShowDescriptions: boolean;
+    canShowFooter: boolean;
+    canShowDetailsPanel: boolean;
+}
+/** Below this width: browse/search use plain output only. */
+export declare const PLAIN_OUTPUT_MAX_COLUMNS = 60;
+export declare const MIN_COLUMNS = 70;
+export declare const MIN_ROWS = 20;
+export declare const COMPACT_MAX_COLUMNS = 90;
+export declare const COMPACT_MAX_ROWS = 28;
+export declare function useResponsiveLayout(): ResponsiveLayout;

package/dist/ui/layout.js

@@ -0,0 +1,44 @@
+import { useState, useEffect } from 'react';
+import { useStdout } from 'ink';
+export function useStdoutDimensions() {
+    const { stdout } = useStdout();
+    const [dimensions, setDimensions] = useState({
+        columns: stdout.columns || 80,
+        rows: stdout.rows || 24,
+    });
+    useEffect(() => {
+        const handler = () => {
+            setDimensions({
+                columns: stdout.columns || 80,
+                rows: stdout.rows || 24,
+            });
+        };
+        stdout.on('resize', handler);
+        return () => {
+            stdout.off('resize', handler);
+        };
+    }, [stdout]);
+    return dimensions;
+}
+/** Below this width: browse/search use plain output only. */
+export const PLAIN_OUTPUT_MAX_COLUMNS = 60;
+export const MIN_COLUMNS = 70;
+export const MIN_ROWS = 20;
+export const COMPACT_MAX_COLUMNS = 90;
+export const COMPACT_MAX_ROWS = 28;
+export function useResponsiveLayout() {
+    const { columns, rows } = useStdoutDimensions();
+    const isTooSmall = columns < MIN_COLUMNS || rows < MIN_ROWS;
+    const isCompact = columns < COMPACT_MAX_COLUMNS || rows < COMPACT_MAX_ROWS;
+    return {
+        columns,
+        rows: Math.max(1, rows - 1),
+        physicalColumns: columns,
+        physicalRows: rows,
+        isTooSmall,
+        isCompact,
+        canShowDescriptions: !isCompact,
+        canShowFooter: true, // Always show footer for now, adjust if needed
+        canShowDetailsPanel: !isCompact && columns > 120, // Optional future use
+    };
+}

package/dist/ui/list-item.d.ts

@@ -0,0 +1,12 @@
+import { MarketplaceAsset } from '../marketplace/types.js';
+export interface ListItem {
+    label: string;
+    value: string;
+    description?: string;
+    badge?: string;
+    metadata?: string[];
+    status?: string;
+    marketplaceAsset?: MarketplaceAsset;
+    rawAsset?: any;
+    scope?: 'global' | 'project';
+}

package/dist/ui/list-item.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/marketplaceDisplay.d.ts

@@ -0,0 +1,10 @@
+import { ProviderResult } from '../types/index.js';
+import { InstallCandidate } from '../services/marketplace.service.js';
+type MarketplaceLike = ProviderResult | InstallCandidate;
+export declare function titleize(value: string): string;
+export declare function sourceLabel(item: MarketplaceLike): string;
+export declare function statusLabel(item: MarketplaceLike): string | undefined;
+export declare function metadataParts(item: MarketplaceLike): string[];
+export declare function verifiedBadge(verified?: boolean): string;
+export declare function shortDescription(description?: string, maxLength?: number): string | undefined;
+export {};

package/dist/ui/marketplaceDisplay.js

@@ -0,0 +1,36 @@
+export function titleize(value) {
+    return value
+        .split(/[-_\s]+/g)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+export function sourceLabel(item) {
+    const sources = item.sources?.length ? item.sources : [item.source];
+    return sources.join(' + ');
+}
+export function statusLabel(item) {
+    return item.installed ? 'installed' : undefined;
+}
+export function metadataParts(item) {
+    const parts = [];
+    if (item.version) {
+        parts.push(`v${item.version}`);
+    }
+    if (item.updated) {
+        parts.push(`Updated ${item.updated}`);
+    }
+    parts.push(`Source: ${sourceLabel(item)}`);
+    return parts;
+}
+export function verifiedBadge(verified) {
+    return verified ? ' ✓ Aman' : '';
+}
+export function shortDescription(description, maxLength = 120) {
+    if (!description)
+        return undefined;
+    const normalized = description.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+}

package/dist/ui/theme.d.ts

@@ -0,0 +1,42 @@
+export declare const darkPalette: {
+    primary: string;
+    accent: string;
+    highlight: string;
+    cyan: string;
+    secondary: string;
+    success: string;
+    error: string;
+    warning: string;
+    dim: string;
+    border: string;
+    borderMuted: string;
+    text: string;
+};
+export declare const lightPalette: {
+    primary: string;
+    accent: string;
+    highlight: string;
+    cyan: string;
+    secondary: string;
+    success: string;
+    error: string;
+    warning: string;
+    dim: string;
+    border: string;
+    borderMuted: string;
+    text: string;
+};
+export declare const theme: {
+    readonly primary: string;
+    readonly accent: string;
+    readonly highlight: string;
+    readonly cyan: string;
+    readonly secondary: string;
+    readonly success: string;
+    readonly error: string;
+    readonly warning: string;
+    readonly dim: string;
+    readonly border: string;
+    readonly borderMuted: string;
+    readonly text: string;
+};

package/dist/ui/theme.js

@@ -0,0 +1,47 @@
+import { config } from '../config/index.js';
+export const darkPalette = {
+    primary: '#FF9D23', // Signature Aman Amber
+    accent: '#A78BFA', // Violet supporting accent
+    highlight: '#FF9D23', // Highlight (Primary Amber)
+    cyan: '#22D3EE',
+    secondary: '#CBD5E1', // Slate 300
+    success: '#34D399', // Emerald 400
+    error: '#F87171', // Red 400
+    warning: '#FBBF24', // Amber 400
+    dim: '#94A3B8', // Slate 400
+    border: '#475569', // Slate 600
+    borderMuted: '#334155', // Slate 700
+    text: '#F8FAFC', // Slate 50
+};
+export const lightPalette = {
+    primary: '#D97706', // High-contrast Dark Amber
+    accent: '#7C3AED', // High-contrast Violet
+    highlight: '#D97706', // Highlight
+    cyan: '#0891B2', // Cyan 600
+    secondary: '#475569', // Slate 600
+    success: '#059669', // Emerald 600
+    error: '#DC2626', // Red 600
+    warning: '#D97706', // Amber 600
+    dim: '#64748B', // Slate 500
+    border: '#CBD5E1', // Slate 300
+    borderMuted: '#E2E8F0', // Slate 200
+    text: '#0F172A', // Slate 900
+};
+function getActivePalette() {
+    const activeTheme = config.getTheme();
+    return activeTheme === 'light' ? lightPalette : darkPalette;
+}
+export const theme = {
+    get primary() { return getActivePalette().primary; },
+    get accent() { return getActivePalette().accent; },
+    get highlight() { return getActivePalette().highlight; },
+    get cyan() { return getActivePalette().cyan; },
+    get secondary() { return getActivePalette().secondary; },
+    get success() { return getActivePalette().success; },
+    get error() { return getActivePalette().error; },
+    get warning() { return getActivePalette().warning; },
+    get dim() { return getActivePalette().dim; },
+    get border() { return getActivePalette().border; },
+    get borderMuted() { return getActivePalette().borderMuted; },
+    get text() { return getActivePalette().text; },
+};

package/dist/utils/asset-list-fields.d.ts

@@ -0,0 +1,11 @@
+import { AssetListItem } from '../types/index.js';
+/** Optional listing fields shared across asset kinds (for union-safe access). */
+export declare function assetListDescription(item: AssetListItem): string | undefined;
+export declare function assetListTags(item: AssetListItem): string[] | undefined;
+export declare function assetListCategory(item: AssetListItem): string | undefined;
+export declare function assetListInstalls(item: AssetListItem): number | undefined;
+export declare function assetListRating(item: AssetListItem): number | undefined;
+export declare function assetListUpdated(item: AssetListItem): string | undefined;
+export declare function assetListVersion(item: AssetListItem): string | undefined;
+export declare function assetListOrganization(item: AssetListItem): string | undefined;
+export declare function assetListOriginalName(item: AssetListItem): string | undefined;

package/dist/utils/asset-list-fields.js

@@ -0,0 +1,28 @@
+/** Optional listing fields shared across asset kinds (for union-safe access). */
+export function assetListDescription(item) {
+    return 'description' in item ? item.description : undefined;
+}
+export function assetListTags(item) {
+    return 'tags' in item ? item.tags : undefined;
+}
+export function assetListCategory(item) {
+    return 'category' in item ? item.category : undefined;
+}
+export function assetListInstalls(item) {
+    return 'installs' in item ? item.installs : undefined;
+}
+export function assetListRating(item) {
+    return 'rating' in item ? item.rating : undefined;
+}
+export function assetListUpdated(item) {
+    return 'updated' in item ? item.updated : undefined;
+}
+export function assetListVersion(item) {
+    return 'version' in item ? item.version : undefined;
+}
+export function assetListOrganization(item) {
+    return 'organization' in item ? item.organization : undefined;
+}
+export function assetListOriginalName(item) {
+    return 'originalName' in item ? item.originalName : undefined;
+}

package/dist/utils/error-message.d.ts

@@ -0,0 +1,2 @@
+/** Extract a user-visible message from an unknown thrown value. */
+export declare function getErrorMessage(err: unknown): string;

package/dist/utils/error-message.js

@@ -0,0 +1,6 @@
+/** Extract a user-visible message from an unknown thrown value. */
+export function getErrorMessage(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}

package/dist/utils/integrity.d.ts

@@ -0,0 +1,9 @@
+import { AssetType } from '../types/index.js';
+export declare const INTEGRITY_ALGORITHM: "sha256";
+export declare function formatChecksum(digest: Buffer): string;
+export declare function hashFileContent(filePath: string): Promise<string>;
+/**
+ * Computes canonical content checksum per AMAN-ASSET-SPEC-V1.
+ * `assetPath` MUST be the asset directory (not a flat file).
+ */
+export declare function computeAssetChecksum(type: AssetType, assetDirectory: string): Promise<string>;

package/dist/utils/integrity.js

@@ -0,0 +1,23 @@
+import { createHash } from 'crypto';
+import { promises as fs } from 'fs';
+import { exists } from '../storage/filesystem.js';
+import { contentFilePath, CONTENT_FILES } from '../storage/asset-layout.js';
+export const INTEGRITY_ALGORITHM = 'sha256';
+export function formatChecksum(digest) {
+    return `sha256:${digest.toString('hex')}`;
+}
+export async function hashFileContent(filePath) {
+    const content = await fs.readFile(filePath);
+    return formatChecksum(createHash('sha256').update(content).digest());
+}
+/**
+ * Computes canonical content checksum per AMAN-ASSET-SPEC-V1.
+ * `assetPath` MUST be the asset directory (not a flat file).
+ */
+export async function computeAssetChecksum(type, assetDirectory) {
+    const contentPath = contentFilePath(assetDirectory, type);
+    if (!exists(contentPath)) {
+        throw new Error(`Missing ${CONTENT_FILES[type]} for checksum: ${assetDirectory}`);
+    }
+    return hashFileContent(contentPath);
+}

package/dist/utils/lock-migrate.d.ts

@@ -0,0 +1,25 @@
+import { AssetType, LockEntry, Lockfile, LockSource, Scope } from '../types/index.js';
+interface LegacyLockEntry {
+    name: string;
+    type: AssetType;
+    source: string;
+    installedAt: string;
+    version?: string;
+    originalName?: string;
+}
+interface LegacyLockfile {
+    version?: number;
+    schemaVersion?: number;
+    skills?: LegacyLockEntry[];
+    prompts?: LegacyLockEntry[];
+    mcps?: LegacyLockEntry[];
+    assets?: LockEntry[];
+    scope?: Scope;
+    generatedAt?: string;
+}
+export declare function parseLockSource(source: string): LockSource;
+/** Normalize legacy or partial lockfiles to AMAN-LOCKFILE-SPEC-V1 shape. */
+export declare function normalizeLockfile(raw: LegacyLockfile | null | undefined, scope: Scope): Lockfile;
+export declare function emptyLockfile(scope: Scope): Lockfile;
+export declare function isLegacyLockfile(raw: LegacyLockfile): boolean;
+export {};

package/dist/utils/lock-migrate.js

@@ -0,0 +1,93 @@
+import { randomUUID } from 'crypto';
+import { defaultSlugForName } from './slug.js';
+import { INTEGRITY_ALGORITHM } from './integrity.js';
+function inferSourceKind(source) {
+    if (source.startsWith('registry:'))
+        return 'registry';
+    if (source.startsWith('github:') || source.includes('/'))
+        return 'github';
+    if (source.startsWith('pack:'))
+        return 'pack';
+    if (source.startsWith('import:'))
+        return 'import';
+    if (source === 'bundled' || source === 'local')
+        return 'local';
+    return 'manual';
+}
+export function parseLockSource(source) {
+    const kind = inferSourceKind(source);
+    if (kind === 'registry' || kind === 'pack' || kind === 'import' || kind === 'github') {
+        return { kind, ref: source };
+    }
+    if (kind === 'local') {
+        return { kind, ref: `local:${source}` };
+    }
+    return { kind: 'manual', ref: `manual:${source}` };
+}
+function migrateLegacyEntry(entry, scope) {
+    return {
+        id: randomUUID(),
+        slug: defaultSlugForName(entry.originalName ?? entry.name),
+        type: entry.type,
+        localName: entry.name,
+        version: entry.version ?? '1.0.0',
+        integrity: {
+            algorithm: INTEGRITY_ALGORITHM,
+            checksum: 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+        },
+        source: parseLockSource(entry.source),
+        scope,
+        installedAt: entry.installedAt,
+        dependencies: [],
+        requiresLocalConfig: entry.type === 'mcp',
+    };
+}
+/** Normalize legacy or partial lockfiles to AMAN-LOCKFILE-SPEC-V1 shape. */
+export function normalizeLockfile(raw, scope) {
+    if (!raw) {
+        return emptyLockfile(scope);
+    }
+    if (Array.isArray(raw.assets)) {
+        return {
+            schemaVersion: 1,
+            generatedAt: raw.generatedAt ?? new Date().toISOString(),
+            scope: raw.scope ?? scope,
+            assets: raw.assets.filter(isValidLockEntry).map((entry) => ({
+                ...entry,
+                scope: entry.scope ?? scope,
+                dependencies: entry.dependencies ?? [],
+                requiresLocalConfig: entry.requiresLocalConfig ?? entry.type === 'mcp',
+            })),
+        };
+    }
+    const legacyEntries = [
+        ...(raw.skills ?? []),
+        ...(raw.prompts ?? []),
+        ...(raw.mcps ?? []),
+    ];
+    return {
+        schemaVersion: 1,
+        generatedAt: raw.generatedAt ?? new Date().toISOString(),
+        scope: raw.scope ?? scope,
+        assets: legacyEntries.map((entry) => migrateLegacyEntry(entry, raw.scope ?? scope)),
+    };
+}
+export function emptyLockfile(scope) {
+    return {
+        schemaVersion: 1,
+        generatedAt: new Date().toISOString(),
+        scope,
+        assets: [],
+    };
+}
+export function isLegacyLockfile(raw) {
+    return !Array.isArray(raw.assets) && !!(raw.skills?.length || raw.prompts?.length || raw.mcps?.length || raw.version === 1);
+}
+function isValidLockEntry(entry) {
+    if (!entry || typeof entry !== 'object')
+        return false;
+    const e = entry;
+    return (typeof e.localName === 'string' &&
+        (e.type === 'skill' || e.type === 'prompt' || e.type === 'mcp') &&
+        typeof e.version === 'string');
+}

package/dist/utils/mcp-local.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Extract env var keys from mcp.json that need local values.
+ */
+export declare function extractMcpEnvKeys(mcpData: Record<string, unknown>): string[];
+export declare function buildMcpLocalTemplate(envKeys: string[]): Record<string, string>;
+/** Create mcp.local.json when missing; never overwrite existing file. */
+export declare function scaffoldMcpLocalConfig(assetDir: string): Promise<{
+    created: boolean;
+    keys: string[];
+}>;
+export declare function mcpRequiresLocalConfig(mcpData: Record<string, unknown>): boolean;
+export declare function ensureMcpLocalGitignore(scopeRoot: string): Promise<boolean>;
+export declare function readGitignoreContent(scopeRoot: string): Promise<string>;
+export declare function gitignoreIncludesMcpLocalAsync(scopeRoot: string): Promise<boolean>;
+export declare function countEmptyMcpLocalValues(assetDir: string): Promise<number>;