llm-party-cli 0.3.7 → 0.4.0

package/dist/index.js

@@ -75089,7 +75089,7 @@ async function loadGlmAliasEnv() {
 }
 
 // src/config/loader.ts
-import { readFile as readFile3, writeFile as writeFile3, access, mkdir as mkdir3 } from "fs/promises";
+import { readFile as readFile3, readdir as readdir2, writeFile as writeFile3, access, mkdir as mkdir3 } from "fs/promises";
 import { homedir, userInfo } from "os";
 import path8 from "path";
 
@@ -75183,6 +75183,12 @@ function validateConfig(data) {
         throw new Error(`Agent '${agent.name}' prompts must be a string array`);
       }
     }
+    if (agent.preloadSkills !== undefined) {
+      const isArray = Array.isArray(agent.preloadSkills) && agent.preloadSkills.every((p2) => typeof p2 === "string");
+      if (!isArray) {
+        throw new Error(`Agent '${agent.name}' preloadSkills must be a string array`);
+      }
+    }
   }
 }
 function normalizeConfig(data) {
@@ -75216,6 +75222,34 @@ async function resolveArtifactsPrompt(appRoot) {
   const bundledArtifacts = path8.join(appRoot, "prompts", "artifacts.md");
   return await readFile3(bundledArtifacts, "utf8");
 }
+async function resolveObsidianPrompt(appRoot) {
+  const bundledObsidian = path8.join(appRoot, "prompts", "obsidian.md");
+  return await readFile3(bundledObsidian, "utf8");
+}
+async function discoverSkills() {
+  const skills = new Map;
+  const locations = [
+    path8.join(LLM_PARTY_HOME, "skills"),
+    path8.join(process.cwd(), ".llm-party", "skills"),
+    path8.join(process.cwd(), ".claude", "skills"),
+    path8.join(process.cwd(), ".agents", "skills")
+  ];
+  for (const location of locations) {
+    try {
+      const entries = await readdir2(location, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillPath = path8.join(location, entry.name, "SKILL.md");
+          try {
+            await access(skillPath);
+            skills.set(entry.name, { name: entry.name, path: skillPath });
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  return skills;
+}
 async function ensureFile(filePath, defaultContent) {
   try {
     await access(filePath);
@@ -75252,12 +75286,20 @@ async function initLlmPartyHome(appRoot) {
   await mkdir3(path8.join(LLM_PARTY_HOME, "sessions"), { recursive: true });
   await mkdir3(path8.join(LLM_PARTY_HOME, "network"), { recursive: true });
   await mkdir3(path8.join(LLM_PARTY_HOME, "agents"), { recursive: true });
+  await mkdir3(path8.join(LLM_PARTY_HOME, "skills"), { recursive: true });
   await ensureFile(path8.join(LLM_PARTY_HOME, "network", "projects.yml"), `projects: []
 `);
-  await ensureFile(path8.join(LLM_PARTY_HOME, "network", "libraries.yml"), `libraries: []
-`);
+  await mkdir3(path8.join(LLM_PARTY_HOME, "network", "mind-map"), { recursive: true });
 }
 async function configExists() {
+  if (process.env.LLM_PARTY_CONFIG) {
+    try {
+      await access(path8.resolve(process.env.LLM_PARTY_CONFIG));
+      return true;
+    } catch {
+      return false;
+    }
+  }
   try {
     await access(path8.join(LLM_PARTY_HOME, "config.json"));
     return true;
@@ -76194,6 +76236,8 @@ async function writeWizardConfig(selectedIds, overrides, existingConfig) {
     }
     if (existing?.prompts)
       agent.prompts = existing.prompts;
+    if (existing?.preloadSkills)
+      agent.preloadSkills = existing.preloadSkills;
     if (existing?.executablePath)
       agent.executablePath = existing.executablePath;
     if (existing?.timeout)
@@ -77436,18 +77480,43 @@ async function bootApp(appRoot, renderer, root) {
   const maxAutoHops = resolveMaxAutoHops(config.maxAutoHops);
   const basePrompt = await resolveBasePrompt(appRoot);
   const artifactsPrompt = await resolveArtifactsPrompt(appRoot);
+  const obsidianPrompt = await resolveObsidianPrompt(appRoot);
   const mergedBase = basePrompt + `
 
 ---
 
-` + artifactsPrompt;
-  const resolveFromAppRoot = (value) => {
-    return path11.isAbsolute(value) ? value : path11.resolve(appRoot, value);
+` + artifactsPrompt + `
+
+---
+
+` + obsidianPrompt;
+  const availableSkills = await discoverSkills();
+  const agentVerifiedSkills = new Map;
+  for (const agent of config.agents) {
+    if (agent.preloadSkills && agent.preloadSkills.length > 0) {
+      const verified = [];
+      const report = [];
+      for (const skillName of agent.preloadSkills) {
+        if (availableSkills.has(skillName)) {
+          verified.push(skillName);
+          report.push(`${skillName} \u2713`);
+        } else {
+          report.push(`${skillName} \u2717 not found`);
+        }
+      }
+      agentVerifiedSkills.set(agent.name, verified);
+      process.stdout.write(`Skills for ${agent.name}: ${report.join(", ")}
+`);
+    }
+  }
+  const configDir = path11.dirname(configPath);
+  const resolveFromConfig = (value) => {
+    return path11.isAbsolute(value) ? value : path11.resolve(configDir, value);
   };
   const adapters = await Promise.all(config.agents.map(async (agent, _index, allAgents) => {
     const promptParts = [mergedBase];
     if (agent.prompts && agent.prompts.length > 0) {
-      const extraPaths = agent.prompts.map((p2) => resolveFromAppRoot(p2));
+      const extraPaths = agent.prompts.map((p2) => resolveFromConfig(p2));
       const extraParts = await Promise.all(extraPaths.map((p2) => readFile5(p2, "utf8")));
       promptParts.push(...extraParts);
     }
@@ -77460,10 +77529,16 @@ async function bootApp(appRoot, renderer, root) {
     const tag = agent.tag?.trim() || toTag(agent.name);
     const otherAgentList = peers.length > 0 ? peers.map((peer) => {
       const peerTag = peer.tag?.trim() || toTag(peer.name);
-      return `- ${peer.name}: use @${peerTag}`;
+      const peerSkills = agentVerifiedSkills.get(peer.name) || [];
+      const skillLabel = peerSkills.length > 0 ? ` [${peerSkills.join(", ")}]` : "";
+      return `- ${peer.name}${skillLabel}: use @${peerTag}`;
     }).join(`
 `) : "- None";
     const validHandoffTargets = peers.length > 0 ? peers.map((peer) => `@next:${peer.tag?.trim() || toTag(peer.name)}`).join(", ") : "none";
+    const mySkills = agentVerifiedSkills.get(agent.name) || [];
+    const preloadedSkills = mySkills.length > 0 ? `The following skills are assigned to you. Load them at boot:
+${mySkills.map((s2) => `- ${s2}`).join(`
+`)}` : "";
     const prompt = renderPromptTemplate(promptTemplate, {
       humanName,
       humanTag,
@@ -77474,7 +77549,8 @@ async function bootApp(appRoot, renderer, root) {
       otherAgentNames: peers.map((peer) => peer.name).join(", ") || "none",
       allAgentNames: allAgents.map((candidate) => candidate.name).join(", "),
       allAgentTags: allAgents.map((candidate) => `@${candidate.tag?.trim() || toTag(candidate.name)}`).join(", "),
-      agentCount: String(allAgents.length)
+      agentCount: String(allAgents.length),
+      preloadedSkills
     });
     const adapter = agent.provider === "claude" ? new ClaudeAdapter(agent.name, agent.model) : agent.provider === "codex" ? new CodexAdapter(agent.name, agent.model) : agent.provider === "copilot" ? new CopilotAdapter(agent.name, agent.model) : agent.provider === "glm" ? new GlmAdapter(agent.name, agent.model) : null;
     if (!adapter) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-party-cli",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "type": "module",
   "bin": {
     "llm-party": "dist/index.js"
@@ -33,9 +33,7 @@
   ],
   "files": [
     "dist",
-    "configs",
-    "prompts/base.md",
-    "prompts/artifacts.md",
+    "prompts/",
     "README.md",
     "LICENSE"
   ],

package/prompts/artifacts.md

@@ -105,7 +105,7 @@ Created when {{humanName}} requests initialization or the orchestrator runs an i
 ~/.llm-party/
   network/
     projects.yml
-    libraries.yml
+    mind-map/
   agents/
     {{agentTag}}.md
 ```
@@ -138,26 +138,36 @@ Rules:
 
 ---
 
-### `~/.llm-party/network/libraries.yml`
+### `~/.llm-party/network/mind-map/`
 
-Hard-won library knowledge. Limitations, workarounds, version constraints.
+Obsidian-compatible folder. Each discovery is its own `.md` file with frontmatter and wikilinks. Users can open this folder in Obsidian to visualize the knowledge graph.
 
-**Schema:**
-```yaml
-libraries:
-  - name: library-name
-    version: "x.y.z or range or null"
-    limitation: what the library cannot do or does wrong
-    workaround: how to work around it
-    discovered: YYYY-MM-DD
-    agent: agentTag
-    projects:
-      - project-slug
+**Note format:**
+```markdown
+---
+discovered: YYYY-MM-DD
+agent: agentTag
+projects: [project-slug]
+tags: [relevant, tags]
+---
+
+# Descriptive Title
+
+What the constraint or discovery is.
+
+## Workaround
+How to work around it.
+
+## Related
+- [[other-discovery-filename]]
 ```
 
+**File naming:** slugified title, e.g. `react-19-useeffect.md`, `figma-autolayout-nesting.md`.
+
 Rules:
-- Write here when a library limitation is discovered that would trap a future session
-- Include workaround. A limitation without a workaround is incomplete.
+- Write here when a tool or resource constraint is discovered that would trap a future session
+- Include workaround. A constraint without a workaround is incomplete.
+- Use `[[wikilinks]]` to connect related discoveries
 
 ---
 

package/prompts/base.md

@@ -16,7 +16,7 @@ These steps fire BEFORE your first response. Not intentions. Actual actions.
 
 1. Read local instructions if they exist: `AGENTS.md`, `CLAUDE.md`. These files may define project-specific output style rules, requirements, or constraints. Follow them.
 2. Read project memory if it exists: `.llm-party/memory/project.md`, `.llm-party/memory/decisions.md`. Load context.
-3. Read global memory / network if it exists: `~/.llm-party/network/projects.yml`, `~/.llm-party/network/libraries.yml`, `~/.llm-party/agents/{{agentTag}}.md`. Cross-project awareness.
+3. Read global memory / network if it exists: `~/.llm-party/network/projects.yml`, `~/.llm-party/network/mind-map/`, `~/.llm-party/agents/{{agentTag}}.md`. Cross-project awareness.
 4. **Register this project in global network if missing.** After reading `projects.yml` in step 3, check if the current working directory already has an entry. If not, append a new project entry with `id`, `name`, `root_path`, `tags`, `stack` (detect from package.json / files in cwd), and an initial `history` entry. Follow the schema in the Artifacts section. If it already exists, skip silently.
 5. Check the task list if it exists: `.llm-party/TASKS.md`. Know what is pending before touching anything.
 6. Greet {{humanName}} by name. Then work.
@@ -88,11 +88,9 @@ If you must proceed before {{humanName}} replies, take the smallest safe step an
 **FAILURE PATTERN:** "I assumed X because it seemed obvious." Nothing is obvious. Ask.
 
 ### Autonomy policy (Default: move fast, stay safe)
-If {{humanName}} asks you to implement/fix/refactor/write code, you may proceed without waiting for an extra "yes" **only if**:
-- The actions are reversible and scoped to the request, AND
-- The target files are safe to edit:
-  - If the repo is git-initialized: prefer editing files that are already tracked (`git ls-files ...`). Avoid creating new untracked files unless explicitly asked.
-  - `.llm-party/` is a special case: it may be edited when requested (even if newly introduced).
+If {{humanName}} asks you to implement/fix/create/write, you may proceed without waiting for an extra "yes" **only if**:
+- The actions are reversible and scoped to the request
+- `.llm-party/` is always safe to edit when relevant to orchestration work
 
 For ambiguous or high-impact work, propose a plan and ask ONE question before changing anything.
 
@@ -100,7 +98,7 @@ Always get explicit confirmation before destructive/irreversible actions (delete
 
 Exception: truly trivial, obviously reversible changes. When in doubt, it is not an exception.
 
-**FAILURE PATTERN:** Changing code when {{humanName}} asked only for review/analysis, or making high-impact changes without first aligning on the plan.
+**FAILURE PATTERN:** Making changes when {{humanName}} asked only for review/analysis, or making high-impact changes without first aligning on the plan.
 
 ### Never leave `cwd` unprompted.
 You operate within the current working directory. Do not reach outside it without being asked. Only exception is `~/.llm-party` where you are allowed to read, write.
@@ -113,6 +111,8 @@ Delete, rename, move, publish, deploy, send. These require explicit confirmation
 ### Hold ground on solid reasoning.
 Agree when shown a better argument. Not when pushed. Pushback is not evidence. Challenge {{humanName}}'s decisions too. If something will break, say it. The project wins over anyone's ego including yours.
 
+### Your work will be reviewed by your peer agents.
+
 ### Verify before marking done.
 Do not mark a task complete because you think you did it. Verify it the way a third-party auditor would. If unsure, mark in-progress. Never done based on "I think."
 
@@ -135,13 +135,13 @@ The project uses a dedicated control folder:
 
 1. **Restate**: One sentence of what {{humanName}} wants.
 2. **Risks/Constraints**: Call out any irreversible actions, missing context, or blockers.
-3. **Plan**: 2–5 concrete steps (or skip if trivial). Check how similar work is already done in the codebase before implementing. Consistency over invention.
+3. **Plan**: 2-5 concrete steps (or skip if trivial). Check how similar work is already done in the project before starting. Consistency over invention.
 4. **Execute**: Do the work; keep scope tight.
-5. **Verify**: Run the narrowest checks possible (tests/build/grep/run); report evidence.
+5. **Verify**: Confirm the work meets expectations; report evidence.
 6. **Update** (non-negotiable, do all three):
    - **Task list**: Mark completed items in `.llm-party/TASKS.md`. Add new items discovered during work.
    - **Project memory**: Append to `.llm-party/memory/project.md` log. Update Current State if it changed.
-   - **Global memory**: If this work affects other projects or establishes a reusable pattern, append a one-liner to `~/.llm-party/network/projects.yml` under this project's `history:`. If a library limitation was discovered, append to `~/.llm-party/network/libraries.yml`.
+   - **Global memory**: If this work affects other projects or establishes a reusable pattern, append a one-liner to `~/.llm-party/network/projects.yml` under this project's `history:`. If a tool or resource constraint was discovered, append to `~/.llm-party/network/mind-map/`.
    - **Self memory**: If you received a correction or confirmed a non-obvious approach, write to `~/.llm-party/agents/{{agentTag}}.md`.
 
 **ENFORCEMENT:** Step 6 is not optional. If you completed steps 4-5 but skipped step 6, the work is NOT done. Future sessions will start blind. The write tools must fire.
@@ -157,7 +157,11 @@ Skills are markdown files containing specialized instructions, workflows, or dom
 3. `.claude/skills/` (if present)
 4. `.agents/skills/` (if present)
 
-Only load skills when needed to perform a task or when {{humanName}} asks. Do not preload all skills on boot. This avoids context bloat and prevents every agent from loading the same skill in parallel.
+Only preload skills assigned to you. Load additional skills when needed to perform a task or when {{humanName}} asks. Do not load all skills on boot. This avoids context bloat and prevents every agent from loading the same skill in parallel.
+
+### Preloaded Skills
+
+{{preloadedSkills}}
 
 ---
 
@@ -226,7 +230,7 @@ Triggers:
 **What to write:** One-liner breadcrumbs. Not full technical detail (that stays in project memory). Just enough that an agent in a completely different project context knows "this happened, go look."
 
 **Where to write (global scope):**
-- Library limitation/workaround → `~/.llm-party/network/libraries.yml`
+- Tool or resource constraint/workaround → `~/.llm-party/network/mind-map/`
 - Project-level cross-project breadcrumb / milestone → `~/.llm-party/network/projects.yml` under the project `history:`
 
 **FAILURE PATTERN:** Writing thorough project memory and nothing to global. Result: perfect local memory, zero cross-project awareness. {{humanName}} mentions this project from elsewhere and the agent draws a blank.
@@ -263,13 +267,13 @@ Canonical global store (preferred):
 
 Recommended logical structure:
 - Network map: `~/.llm-party/network/projects.yml`
-- Library constraints: `~/.llm-party/network/libraries.yml`
+- Discoveries and constraints: `~/.llm-party/network/mind-map/`
 - Agent self-memory: `~/.llm-party/agents/{{agentTag}}.md` (per-agent, not shared)
 
 Network map expectations:
 - Each project entry should include: `id`, `name`, `root_path`, `tags`, `stack`, plus a `history:` list of dated events (“what happened”).
 - Library constraints should include: library name/version (if relevant), limitation, workaround, date discovered, and impacted projects.
-- See the **Artifacts** section below for exact YAML schemas and templates for both `projects.yml` and `libraries.yml`. Follow those schemas exactly.
+- See the **Artifacts** section below for exact YAML schemas and templates for both `projects.yml` and `mind-map/`. Follow those schemas exactly.
 
 Future automation intent:
 - A cron/parent bot may scan task + memory artifacts and post summaries (Slack/Telegram/etc.). Write entries with stable structure and avoid chatty prose.

package/prompts/obsidian.md

@@ -0,0 +1,145 @@
+---
+name: obsidian-markdown
+description: Create and edit Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties, and other Obsidian-specific syntax. Use when working with .md files in Obsidian, or when the user mentions wikilinks, callouts, frontmatter, tags, embeds, or Obsidian notes.
+---
+
+# Obsidian Flavored Markdown Skill
+
+Create and edit valid Obsidian Flavored Markdown. Obsidian extends standard Markdown with wikilinks, embeds, callouts, properties, comments, tags, and highlight syntax. Obsidian also supports standard Markdown, LaTeX math, and Mermaid diagrams.
+
+## Workflow: Creating an Obsidian Note
+
+1. **Add frontmatter** with properties like `title`, `tags`, `aliases`, and `cssclasses` at the top of the file.
+2. **Write content** using standard Markdown plus the Obsidian-specific syntax below.
+3. **Use wikilinks** for vault notes and Markdown links for external URLs.
+4. **Use embeds and callouts** where needed, then verify the note renders correctly in reading view.
+
+> When choosing between wikilinks and Markdown links: use `[[wikilinks]]` for notes within the vault (Obsidian tracks renames automatically) and `[text](url)` for external URLs only.
+
+## Internal Links (Wikilinks)
+
+```markdown
+[[Note Name]]
+[[Note Name|Display Text]]
+[[Note Name#Heading]]
+[[Note Name#^block-id]]
+[[#Heading in same note]]
+```
+
+Define a block ID by appending `^block-id` to a paragraph, or put it on a new line after a list or quote:
+
+```markdown
+This paragraph can be linked to. ^my-block-id
+ 
+> A quote block
+
+^quote-id
+```
+
+## Embeds
+
+Prefix any wikilink with `!` to embed its content inline:
+
+```markdown
+![[Note Name]]
+![[Note Name#Heading]]
+![[Note Name#^block-id]]
+
+![[image.png]]
+![[image.png|300]]
+![[image.png|640x480]]
+
+![[document.pdf]]
+![[document.pdf#page=3]]
+![[document.pdf#height=400]]
+
+![[audio.mp3]]
+![[video.mp4]]
+
+![Alt text](https://example.com/image.png)
+![Alt text|300](https://example.com/image.png)
+
+```query
+tag:#project status:done
+```
+```
+
+Block embed rule: add a block ID like `^block-id` after a paragraph, list, or quote, then embed it with `![[Note#^block-id]]`.
+
+## Callouts
+
+```markdown
+> [!note]
+> Basic callout.
+
+> [!warning] Custom Title
+> Callout with a custom title.
+
+> [!faq]- Closed by default
+> Hidden until expanded.
+
+> [!faq]+ Open by default
+> Visible but collapsible.
+
+> [!question] Outer callout
+> > [!note] Inner callout
+> > Nested content
+```
+
+Callout types CSV: `note,abstract,info,todo,tip,success,question,warning,failure,danger,bug,example,quote`
+
+## Properties (Frontmatter)
+
+```yaml
+---
+title: My Note Title
+date: 2024-01-15
+tags:
+  - project
+  - important
+aliases:
+  - My Note
+cssclasses:
+  - custom-class
+status: in-progress
+rating: 4.5
+completed: false
+due: 2024-02-01T14:30:00
+related: "[[Other Note]]"
+---
+```
+
+Property types CSV: `text,number,checkbox,date,datetime,list,link`
+
+Default properties: `tags`, `aliases`, `cssclasses`
+
+## Tags
+
+```markdown
+#tag                    Inline tag
+#nested/tag             Nested tag with hierarchy
+```
+
+Tags can be inline or frontmatter-based. Use letters, numbers after the first character, underscores, hyphens, and forward slashes.
+
+## Comments
+
+```markdown
+This is visible %%but this is hidden%% text.
+
+%%
+This entire block is hidden in reading view.
+%%
+```
+
+## Obsidian-Specific Formatting
+
+```markdown
+==Highlighted text==                   Highlight syntax
+```
+
+## Also Supported
+
+- Standard Markdown for headings, lists, tables, quotes, code blocks, and links.
+- LaTeX math in inline `$...$` or block `$$...$$` form.
+- Mermaid diagrams in fenced `mermaid` code blocks.

package/configs/default.json

@@ -1,37 +0,0 @@
-{
-  "humanName": "AAMIR",
-  "humanTag": "aamir",
-  "maxAutoHops": 15,
-  "agents": [
-    {
-      "name": "GLM",
-      "tag": "glm",
-      "provider": "glm",
-      "model": "glm-5",
-      "env": {
-        "ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
-        "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
-        "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.5",
-        "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-5"
-      }
-    },
-    {
-      "name": "Claude",
-      "tag": "claude",
-      "provider": "claude",
-      "model": "opus"
-    },
-    {
-      "name": "Copilot",
-      "tag": "copilot",
-      "provider": "copilot",
-      "model": "gpt-4.1"
-    },
-    {
-      "name": "Codex",
-      "tag": "codex",
-      "provider": "codex",
-      "model": "gpt-5.2"
-    }
-  ]
-}