@bamptee/aia-code 2.0.0 → 2.0.2

package/src/ui/api/worktrunk.js

@@ -0,0 +1,153 @@
+import {
+  isWtInstalled,
+  listWorktrees,
+  createWorktree,
+  getWorktreePath,
+  hasWorktree,
+  removeWorktree,
+  getFeatureBranch,
+  startServices,
+  stopServices,
+  hasDockerServices,
+  getServicesStatus,
+} from '../../services/worktrunk.js';
+import { json, error } from '../router.js';
+
+export function registerWorktrunkRoutes(router) {
+  // Check if wt CLI is installed
+  router.get('/api/wt/status', async (req, res) => {
+    const installed = isWtInstalled();
+    json(res, { installed });
+  });
+
+  // Get worktree status for a feature
+  router.get('/api/features/:name/wt', async (req, res, { params, root }) => {
+    const installed = isWtInstalled();
+    if (!installed) {
+      return json(res, {
+        installed: false,
+        hasWorktree: false,
+        path: null,
+        hasServices: false,
+      });
+    }
+
+    const branch = getFeatureBranch(params.name);
+    const wtPath = getWorktreePath(branch, root);
+    const hasWt = wtPath !== null;
+    const hasServices = hasWt && hasDockerServices(wtPath);
+
+    json(res, {
+      installed: true,
+      hasWorktree: hasWt,
+      path: wtPath,
+      branch,
+      hasServices,
+    });
+  });
+
+  // Create a worktree for a feature
+  router.post('/api/features/:name/wt/create', async (req, res, { params, root }) => {
+    const installed = isWtInstalled();
+    if (!installed) {
+      return error(res, 'Worktrunk (wt) CLI is not installed', 400);
+    }
+
+    const branch = getFeatureBranch(params.name);
+
+    // Check if worktree already exists
+    if (hasWorktree(branch, root)) {
+      return error(res, `Worktree for branch "${branch}" already exists`, 400);
+    }
+
+    try {
+      createWorktree(branch, root);
+      const wtPath = getWorktreePath(branch, root);
+      json(res, {
+        ok: true,
+        branch,
+        path: wtPath,
+      }, 201);
+    } catch (err) {
+      error(res, `Failed to create worktree: ${err.message}`, 500);
+    }
+  });
+
+  // Remove a worktree for a feature
+  router.delete('/api/features/:name/wt', async (req, res, { params, root }) => {
+    const installed = isWtInstalled();
+    if (!installed) {
+      return error(res, 'Worktrunk (wt) CLI is not installed', 400);
+    }
+
+    const branch = getFeatureBranch(params.name);
+
+    if (!hasWorktree(branch, root)) {
+      return error(res, `No worktree found for branch "${branch}"`, 404);
+    }
+
+    try {
+      removeWorktree(branch, root);
+      json(res, { ok: true });
+    } catch (err) {
+      error(res, `Failed to remove worktree: ${err.message}`, 500);
+    }
+  });
+
+  // Start docker services in worktree
+  router.post('/api/features/:name/wt/services/start', async (req, res, { params, root }) => {
+    const branch = getFeatureBranch(params.name);
+    const wtPath = getWorktreePath(branch, root);
+
+    if (!wtPath) {
+      return error(res, 'No worktree found for this feature', 404);
+    }
+
+    if (!hasDockerServices(wtPath)) {
+      return error(res, 'No docker-compose.wt.yml found in worktree', 404);
+    }
+
+    try {
+      startServices(wtPath);
+      json(res, { ok: true });
+    } catch (err) {
+      error(res, `Failed to start services: ${err.message}`, 500);
+    }
+  });
+
+  // Stop docker services in worktree
+  router.post('/api/features/:name/wt/services/stop', async (req, res, { params, root }) => {
+    const branch = getFeatureBranch(params.name);
+    const wtPath = getWorktreePath(branch, root);
+
+    if (!wtPath) {
+      return error(res, 'No worktree found for this feature', 404);
+    }
+
+    if (!hasDockerServices(wtPath)) {
+      return error(res, 'No docker-compose.wt.yml found in worktree', 404);
+    }
+
+    try {
+      stopServices(wtPath);
+      json(res, { ok: true });
+    } catch (err) {
+      error(res, `Failed to stop services: ${err.message}`, 500);
+    }
+  });
+
+  // Get services status
+  router.get('/api/features/:name/wt/services', async (req, res, { params, root }) => {
+    const branch = getFeatureBranch(params.name);
+    const wtPath = getWorktreePath(branch, root);
+
+    if (!wtPath) {
+      return json(res, { services: [], hasServices: false });
+    }
+
+    const hasServices = hasDockerServices(wtPath);
+    const services = hasServices ? getServicesStatus(wtPath) : [];
+
+    json(res, { services, hasServices });
+  });
+}

package/src/ui/public/components/config-view.js

@@ -63,6 +63,188 @@ function FileList({ title, files, selectedFile, onSelect }) {
   );
 }
 
+function UserPreferences() {
+  const [prefs, setPrefs] = React.useState({
+    user_name: '',
+    communication_language: 'English',
+  });
+  const [configPath, setConfigPath] = React.useState('');
+  const [loading, setLoading] = React.useState(true);
+  const [saving, setSaving] = React.useState(false);
+  const [dirty, setDirty] = React.useState(false);
+  const [msg, setMsg] = React.useState(null);
+
+  React.useEffect(() => {
+    api.get('/user-config').then(data => {
+      const parsed = data.parsed || {};
+      setPrefs({
+        user_name: parsed.user_name || '',
+        communication_language: parsed.communication_language || 'English',
+      });
+      setConfigPath(data.path || '');
+    }).catch(() => {}).finally(() => setLoading(false));
+  }, []);
+
+  const handleChange = (field, value) => {
+    setPrefs(p => ({ ...p, [field]: value }));
+    setDirty(true);
+  };
+
+  const save = async () => {
+    setSaving(true);
+    setMsg(null);
+    try {
+      await api.patch('/user-config', prefs);
+      setDirty(false);
+      setMsg({ type: 'ok', text: 'Saved.' });
+    } catch (e) {
+      setMsg({ type: 'err', text: e.message });
+    }
+    setSaving(false);
+  };
+
+  if (loading) return React.createElement('p', { className: 'text-slate-500 text-sm' }, 'Loading...');
+
+  const languages = ['English', 'French', 'Spanish', 'German', 'Portuguese', 'Italian', 'Dutch', 'Russian', 'Chinese', 'Japanese', 'Korean'];
+
+  return React.createElement('div', { className: 'bg-aia-card border border-aia-border rounded p-4 space-y-4' },
+    React.createElement('div', { className: 'flex items-center justify-between' },
+      React.createElement('h3', { className: 'text-sm font-semibold text-cyan-400' }, 'User Preferences'),
+      React.createElement('div', { className: 'flex gap-2 items-center' },
+        dirty && React.createElement('span', { className: 'text-xs text-amber-400' }, 'unsaved'),
+        msg && React.createElement('span', { className: `text-xs ${msg.type === 'ok' ? 'text-emerald-400' : 'text-red-400'}` }, msg.text),
+        React.createElement('button', {
+          onClick: save,
+          disabled: saving || !dirty,
+          className: 'bg-aia-accent/20 text-aia-accent border border-aia-accent/30 rounded px-3 py-1 text-xs hover:bg-aia-accent/30 disabled:opacity-40',
+        }, saving ? '...' : 'Save'),
+      ),
+    ),
+
+    React.createElement('div', { className: 'grid grid-cols-2 gap-4' },
+      // User name
+      React.createElement('div', { className: 'space-y-1' },
+        React.createElement('label', { className: 'text-xs text-slate-400' }, 'Your Name'),
+        React.createElement('input', {
+          type: 'text',
+          value: prefs.user_name,
+          onChange: e => handleChange('user_name', e.target.value),
+          placeholder: 'Optional',
+          className: 'w-full bg-slate-900 border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 placeholder-slate-500 focus:border-aia-accent focus:outline-none',
+        }),
+      ),
+
+      // Communication language
+      React.createElement('div', { className: 'space-y-1' },
+        React.createElement('label', { className: 'text-xs text-slate-400' }, 'Communication Language'),
+        React.createElement('select', {
+          value: prefs.communication_language,
+          onChange: e => handleChange('communication_language', e.target.value),
+          className: 'w-full bg-slate-900 border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 focus:border-aia-accent focus:outline-none',
+        },
+          ...languages.map(lang => React.createElement('option', { key: lang, value: lang }, lang)),
+        ),
+      ),
+    ),
+
+    React.createElement('p', { className: 'text-xs text-slate-500' },
+      'Your personal preferences. Stored globally in ~/.aia/ and apply to all projects.'
+    ),
+    configPath && React.createElement('p', { className: 'text-xs text-slate-600' },
+      `Location: ${configPath}`
+    ),
+  );
+}
+
+function ProjectSettings({ onSaved }) {
+  const [settings, setSettings] = React.useState({
+    projectName: '',
+    document_output_language: 'English',
+  });
+  const [loading, setLoading] = React.useState(true);
+  const [saving, setSaving] = React.useState(false);
+  const [dirty, setDirty] = React.useState(false);
+  const [msg, setMsg] = React.useState(null);
+
+  React.useEffect(() => {
+    api.get('/config').then(data => {
+      const parsed = data.parsed || {};
+      setSettings({
+        projectName: parsed.projectName || '',
+        document_output_language: parsed.document_output_language || 'English',
+      });
+    }).catch(() => {}).finally(() => setLoading(false));
+  }, []);
+
+  const handleChange = (field, value) => {
+    setSettings(p => ({ ...p, [field]: value }));
+    setDirty(true);
+  };
+
+  const save = async () => {
+    setSaving(true);
+    setMsg(null);
+    try {
+      await api.patch('/config/project', settings);
+      setDirty(false);
+      setMsg({ type: 'ok', text: 'Saved.' });
+      if (onSaved) onSaved();
+    } catch (e) {
+      setMsg({ type: 'err', text: e.message });
+    }
+    setSaving(false);
+  };
+
+  if (loading) return React.createElement('p', { className: 'text-slate-500 text-sm' }, 'Loading...');
+
+  const languages = ['English', 'French', 'Spanish', 'German', 'Portuguese', 'Italian', 'Dutch', 'Russian', 'Chinese', 'Japanese', 'Korean'];
+
+  return React.createElement('div', { className: 'bg-aia-card border border-aia-border rounded p-4 space-y-4' },
+    React.createElement('div', { className: 'flex items-center justify-between' },
+      React.createElement('h3', { className: 'text-sm font-semibold text-violet-400' }, 'Project Settings'),
+      React.createElement('div', { className: 'flex gap-2 items-center' },
+        dirty && React.createElement('span', { className: 'text-xs text-amber-400' }, 'unsaved'),
+        msg && React.createElement('span', { className: `text-xs ${msg.type === 'ok' ? 'text-emerald-400' : 'text-red-400'}` }, msg.text),
+        React.createElement('button', {
+          onClick: save,
+          disabled: saving || !dirty,
+          className: 'bg-aia-accent/20 text-aia-accent border border-aia-accent/30 rounded px-3 py-1 text-xs hover:bg-aia-accent/30 disabled:opacity-40',
+        }, saving ? '...' : 'Save'),
+      ),
+    ),
+
+    React.createElement('div', { className: 'grid grid-cols-2 gap-4' },
+      // Project name
+      React.createElement('div', { className: 'space-y-1' },
+        React.createElement('label', { className: 'text-xs text-slate-400' }, 'Project Name'),
+        React.createElement('input', {
+          type: 'text',
+          value: settings.projectName,
+          onChange: e => handleChange('projectName', e.target.value),
+          placeholder: 'My Project',
+          className: 'w-full bg-slate-900 border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 placeholder-slate-500 focus:border-aia-accent focus:outline-none',
+        }),
+      ),
+
+      // Document output language
+      React.createElement('div', { className: 'space-y-1' },
+        React.createElement('label', { className: 'text-xs text-slate-400' }, 'Document Output Language'),
+        React.createElement('select', {
+          value: settings.document_output_language,
+          onChange: e => handleChange('document_output_language', e.target.value),
+          className: 'w-full bg-slate-900 border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 focus:border-aia-accent focus:outline-none',
+        },
+          ...languages.map(lang => React.createElement('option', { key: lang, value: lang }, lang)),
+        ),
+      ),
+    ),
+
+    React.createElement('p', { className: 'text-xs text-slate-500' },
+      'Project-wide settings. Stored in .aia/config.yaml and shared with your team.'
+    ),
+  );
+}
+
 export function ConfigView() {
   const [contextFiles, setContextFiles] = React.useState([]);
   const [knowledgeCategories, setKnowledgeCategories] = React.useState([]);
@@ -71,12 +253,17 @@ export function ConfigView() {
   const [selectedCategory, setSelectedCategory] = React.useState(null);
   const [logs, setLogs] = React.useState('');
   const [showLogs, setShowLogs] = React.useState(false);
+  const [configVersion, setConfigVersion] = React.useState(0);
 
   React.useEffect(() => {
     api.get('/context').then(setContextFiles).catch(() => {});
     api.get('/knowledge').then(setKnowledgeCategories).catch(() => {});
   }, []);
 
+  const handlePreferencesSaved = () => {
+    setConfigVersion(v => v + 1);
+  };
+
   function selectContext(f) {
     setSelectedFile(f);
     setSelectedType('context');
@@ -100,9 +287,16 @@ export function ConfigView() {
   return React.createElement('div', { className: 'space-y-6' },
     React.createElement('h1', { className: 'text-xl font-bold text-slate-100' }, 'Configuration'),
 
-    // config.yaml
+    // Two columns: User Preferences + Project Settings
+    React.createElement('div', { className: 'grid grid-cols-2 gap-4' },
+      React.createElement(UserPreferences),
+      React.createElement(ProjectSettings, { onSaved: handlePreferencesSaved }),
+    ),
+
+    // config.yaml (advanced)
     React.createElement(YamlEditor, {
-      title: 'config.yaml',
+      key: `config-${configVersion}`,
+      title: 'config.yaml (advanced)',
       loadFn: async () => (await api.get('/config')).content,
       saveFn: async (content) => api.put('/config', { content }),
     }),

package/src/ui/public/components/dashboard.js

@@ -24,7 +24,13 @@ function FeatureCard({ feature }) {
     className: 'block bg-aia-card border border-aia-border rounded-lg p-4 hover:border-aia-accent/50 transition-colors',
   },
     React.createElement('div', { className: 'flex items-center justify-between mb-3' },
-      React.createElement('h3', { className: 'text-slate-100 font-semibold' }, feature.name),
+      React.createElement('div', { className: 'flex items-center gap-2' },
+        React.createElement('h3', { className: 'text-slate-100 font-semibold' }, feature.name),
+        feature.hasWorktree && React.createElement('span', {
+          className: 'bg-orange-500/20 text-orange-400 text-xs px-1.5 py-0.5 rounded',
+          title: 'Git worktree active',
+        }, 'wt'),
+      ),
       React.createElement('span', { className: 'text-xs text-slate-500' },
         `${doneCount}/${totalCount} steps`
       ),
@@ -167,9 +173,40 @@ function QuickTicketForm({ onDone }) {
   );
 }
 
+function FilterTabs({ filter, onChange, counts }) {
+  const tabs = [
+    { key: 'all', label: 'All', count: counts.all },
+    { key: 'with-wt', label: 'With Worktree', count: counts.withWt },
+    { key: 'without-wt', label: 'Without Worktree', count: counts.withoutWt },
+  ];
+
+  return React.createElement('div', { className: 'flex gap-1 border-b border-aia-border' },
+    ...tabs.map(tab =>
+      React.createElement('button', {
+        key: tab.key,
+        onClick: () => onChange(tab.key),
+        className: `px-3 py-1.5 text-xs border-b-2 transition-colors flex items-center gap-1.5 ${
+          filter === tab.key
+            ? 'border-aia-accent text-aia-accent'
+            : 'border-transparent text-slate-500 hover:text-slate-300'
+        }`,
+      },
+        tab.label,
+        tab.key === 'with-wt' && tab.count > 0 && React.createElement('span', {
+          className: 'bg-orange-500/20 text-orange-400 text-xs px-1.5 py-0.5 rounded',
+        }, tab.count),
+        tab.key !== 'with-wt' && React.createElement('span', {
+          className: 'text-slate-600',
+        }, `(${tab.count})`),
+      )
+    )
+  );
+}
+
 export function Dashboard() {
   const [features, setFeatures] = React.useState([]);
   const [loading, setLoading] = React.useState(true);
+  const [filter, setFilter] = React.useState('all');
 
   async function load() {
     try {
@@ -181,6 +218,20 @@ export function Dashboard() {
 
   React.useEffect(() => { load(); }, []);
 
+  // Filter features
+  const filteredFeatures = features.filter(f => {
+    if (filter === 'with-wt') return f.hasWorktree;
+    if (filter === 'without-wt') return !f.hasWorktree;
+    return true;
+  });
+
+  // Counts for tabs
+  const counts = {
+    all: features.length,
+    withWt: features.filter(f => f.hasWorktree).length,
+    withoutWt: features.filter(f => !f.hasWorktree).length,
+  };
+
   return React.createElement('div', { className: 'space-y-6' },
     React.createElement('div', { className: 'flex items-center justify-between' },
       React.createElement('h1', { className: 'text-xl font-bold text-slate-100' }, 'Features'),
@@ -190,12 +241,21 @@ export function Dashboard() {
     // Quick ticket
     React.createElement(QuickTicketForm, { onDone: load }),
 
+    // Filter tabs
+    !loading && features.length > 0 && React.createElement(FilterTabs, {
+      filter,
+      onChange: setFilter,
+      counts,
+    }),
+
     loading
       ? React.createElement('p', { className: 'text-slate-500' }, 'Loading...')
       : features.length === 0
         ? React.createElement('p', { className: 'text-slate-500' }, 'No features yet. Create one to get started.')
-        : React.createElement('div', { className: 'grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4' },
-            ...features.map(f => React.createElement(FeatureCard, { key: f.name, feature: f }))
-          )
+        : filteredFeatures.length === 0
+          ? React.createElement('p', { className: 'text-slate-500' }, 'No features match this filter.')
+          : React.createElement('div', { className: 'grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4' },
+              ...filteredFeatures.map(f => React.createElement(FeatureCard, { key: f.name, feature: f }))
+            )
   );
 }