ankn/Orchestrator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate all repos into monorepo context folders

Browse Source 
Bahn: aisupport, Analyse-O2C-C2S, awesome-bahn-mcp-servers, beam-mcp,
      Confluence_Bot, db-planet-mcp-server, O2C-Harness, project-audit,
      Projekt-KIQ-HP, teamlandkarte-mcp
Dhive: Jury-Voting
Privat: CV, NoteGraph (NOTE: NoteGraph needs complete redo after consolidation)
Shared: AI-Orchestrator, OrgMyLife, power_skills_and_more
Shared/references: symphony (read-only)

Bahn repos remain available as independent remotes - this monorepo
pulls them in via subtree, the originals are untouched.
This commit is contained in:
ankn
2026-06-30 20:39:52 +02:00
parent 2f2b295531
commit a5f8fb49ab
1717 changed files with 447332 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
privat/CV/.kiro/skills/consultant-profile/SKILL.md
+140
View File
@@ -0,0 +1,140 @@
---
name: consultant-profile
description: Generates tailored consultant profiles (one-pager) from knowledge base data, matched against a specific RFP or project description.
activation: manual
---
# consultant-profile
Generates consultant/personnel profiles tailored to a specific RFP (Request for Proposal) or project description. Produces an HTML one-pager optimized for A4 landscape PDF export, using the d-hive Corporate Design (white background, black accents, neon green highlights). Outputs to `output/profiles/`.
## Activation
Activated by user request with an RFP or project context. Example triggers:
- "create a consultant profile for this RFP"
- "I need a personnel profile for an offer"
- "generate a Berater-Profil for [project]"
- "write a one-pager for [client]"
## Inputs
- **RFP / Leistungsbeschreibung** (required): The requirements document or project description to match against. Used to select relevant skills, projects, and experience.
- **Person ID** (optional): Which profile to generate for. Defaults to the primary profile.
- **Output filename** (optional): Custom filename. Defaults to `<person-id>-berater-profil`.
- **Role in project** (optional): The specific role the person will fill (e.g., "Projektleitung, KI-Beratung & Entwicklung, Workshop-Moderation").
## Workflow
### 1. Load person profile
- Read the target person profile from `kb/profiles/<person-id>.yaml`
- Read `kb/graph-index.yaml` to discover related entities
- Load all referenced entities: skills, experiences, projects, certifications, organizations
### 2. Analyze RFP requirements
- Extract required competencies from the RFP (fachliche, methodische, sonstige)
- Identify required references/project experience
- Note any specific constraints (availability, location, certifications)
### 3. Match and prioritize
- Map person's skills to RFP requirements — highlight direct matches
- Select the most relevant project experiences (max 5) that demonstrate required competencies
- Prioritize: direct match to RFP context > recent > high-impact
- Flag gaps where the person may not fully match (for user review)
### 4. Generate HTML one-pager
Structure (A4 landscape, 3-column layout):
**Header:**
- Profile photo (circular, from project root)
- Name + Job title ("Mensch-Maschine-Moderator")
- Contact meta (location, website, LinkedIn, email)
- d-hive logo (same height as photo)
**Kurzprofil:**
- 2-3 sentence summary emphasizing relevance to the RFP
**Column 1 — Kompetenzen:**
- Fachliche Kompetenzen (skill tags, highlighted = direct RFP match)
- Methodische Kompetenzen (skill tags)
- Zertifizierungen (checklist)
**Column 2 — Projekterfahrung:**
- Up to 5 reference boxes (most relevant first, "featured" styling for top matches)
- Publikationen section below
**Column 3 — Werdegang & Company:**
- Beruflicher Werdegang & Ausbildung (2-column sub-grid)
- Publikationen (if not in column 2)
- Data Hive Cassel company box (green top-border)
**Stats Bar (footer):**
- Key numbers in neon green on black background
### 5. Apply Corporate Design
- **Background:** White (#ffffff)
- **Text:** Near-black (#1a1a1a)
- **Accent/Highlights:** Neon green (#39ff14 / #2bcc0f)
- **Cards:** Light gray (#f6f6f6) with subtle border
- **Featured elements:** Green left-border (3px)
- **Section titles:** Neon green, uppercase, small
- **Stats bar:** Black background, neon green numbers (only large dark element)
- **Skill tags highlighted:** White background, green border
- **Logo:** `assets/d-Hive_logo_darkText_transparent_crop.png` (for white background)
- **Photo:** `assets/230823_Einfachbahn_Andre-brillenlos-hochformat.png` (circular crop)
### 6. Write outputs
- Write HTML to `output/profiles/<filename>.html`
- Optionally write a Markdown summary to `output/profiles/<filename>.md`
- Present to user for review
## Output
- HTML one-pager: `output/profiles/<filename>.html` — print as PDF via browser (Ctrl+P, landscape, no margins)
- Optional Markdown: `output/profiles/<filename>.md` — quick-reference version
## Corporate Design Reference
The d-hive CD uses:
- **Colors:** Black (#0a0a0a) + Neon Green (#39ff14)
- **On white backgrounds:** Use black for structure, neon green for highlights/accents
- **On dark backgrounds:** Use neon green for text highlights
- **Logo variants:** `assets/d-Hive_logo_darkText_transparent_crop.png` (light bg), `assets/d-Hive_logo_transparent_crop.png` (dark bg)
- **Typography:** Inter (Google Fonts), clean and modern
- **Principle:** Neon green = signal/focus, black = structure/anchor, white = breathing room
## Key Facts (for stats bar)
- 50+ Projekte
- 15+ Kunden
- 13+ Jahre KI-Erfahrung (erste ML-Publikation 2012)
- 60+ wissenschaftliche Veröffentlichungen, 2.000+ Zitationen
- 6 Live Use Cases (Projekt KIQ)
- 100% DSGVO & AI-Act konform
## Shared Modules
- `src/schemas/validate.ts` — Entity validation
- `src/schemas/types.ts` — TypeScript type definitions
- `src/io/yaml-utils.ts` — YAML serialization/deserialization
- `src/io/entity-files.ts` — Entity file read management
- `src/cv/relevance-selection.ts` — Relevance matching logic
## Rules and Constraints
1. **No fabrication** — only include information present in the knowledge base
2. **RFP-driven** — prioritize skills and experience that match the RFP requirements
3. **One page** — HTML must fit on a single A4 landscape page when printed
4. **CD compliance** — follow d-hive Corporate Design (black + neon green on white)
5. **Photo required** — always include the profile photo
6. **Logo required** — always include the d-hive logo at same height as photo
7. **No team stats** — profile is personal; don't include team-level metrics (e.g., "30+ Jahre Erfahrung im Team")
8. **Featured projects** — mark the 1-2 most relevant projects with green left-border
9. **Google Scholar link** — always link to the scholar profile in publications
10. **Print-optimized** — use @page CSS for clean PDF export, no overflow
privat/CV/.kiro/skills/cv-generate/SKILL.md
+102
View File
@@ -0,0 +1,102 @@
---
name: cv-generate
description: Generates tailored CVs from knowledge base data, matched against a specific job posting.
activation: manual
---
# cv-generate
Generates tailored CVs from knowledge base data, matched against a specific job posting. Supports individual CVs and combined tandem CVs for job sharing applications. Outputs Markdown files to `output/cvs/`.
## Activation
Activated by user request with a job posting as input. Example triggers:
- "generate a CV for this job posting"
- "create a CV for [job title]"
- "apply to this position"
- "generate tandem CV for this role"
## Inputs
- **Job posting** (required): The job posting text or a file path to the posting. Used to determine which skills, experiences, and qualifications to emphasize.
- **Person ID** (optional): Which profile to generate a CV for. Defaults to the primary profile if only one exists.
- **Tandem ID** (optional): If provided, generates a full tandem application set (combined tandem CV + individual CVs for each partner).
- **Output filename prefix** (optional): Custom prefix for output files. Defaults to `<person-id>-<date>`.
## Workflow
### 1. Parse job posting
- Extract key requirements from the job posting: required skills, desired experience areas, qualifications, responsibilities, and keywords
- Identify the role title, organization, and domain for context
### 2. Load knowledge base data
- Read the target person profile from `kb/profiles/<person-id>.yaml`
- Read `kb/graph-index.yaml` to discover related entities
- Load all referenced experiences from `kb/experiences/`
- Load all referenced skills from `kb/skills/`
- Load all referenced projects from `kb/projects/`
- Load all referenced certifications from `kb/certifications/`
- Load referenced organizations from `kb/organizations/`
### 3. Select relevant content
- Use relevance selection logic (`src/cv/relevance-selection.ts`) to score and rank experiences, skills, and projects against the job posting requirements
- Select entries with non-empty intersection with posting requirements
- Order selected items by relevance: matching items appear before non-matching items
- Retain a minimal set of non-matching items for completeness where appropriate
### 4. Generate individual CV
- Apply the individual CV template (`templates/cv-individual.md`)
- Structure the CV with sections ordered by relevance to the posting
- Emphasize matching skills and experiences in descriptions
- Include only information present in the knowledge base — never fabricate content
- Write output to `output/cvs/<prefix>-individual.md`
### 5. Generate tandem CV (if tandem application)
- Load tandem entity from `kb/tandems/<tandem-id>.yaml`
- Load both partner profiles and their related entities
- Use tandem generation logic (`src/cv/tandem-generator.ts`) to produce the combined CV
- Show complementary qualifications, shared vision, and collaboration model
- Apply the tandem CV template (`templates/cv-tandem.md`)
- Write combined tandem CV to `output/cvs/<prefix>-tandem.md`
- Generate individual CVs for each partner tailored to the same posting
- Write partner CVs to `output/cvs/<prefix>-<partner-id>-individual.md`
### 6. Review and present output
- List all generated files with a brief summary of what each contains
- Highlight which skills and experiences were emphasized
- Note any gaps where the knowledge base lacked information relevant to the posting
## Output
- Individual CV: `output/cvs/<prefix>-individual.md`
- Tandem CV (if applicable): `output/cvs/<prefix>-tandem.md`
- Partner individual CVs (if tandem): `output/cvs/<prefix>-<partner-id>-individual.md`
## Rules and Constraints
1. **No fabrication** — only include information present in the knowledge base; never invent skills, experiences, or qualifications
2. **Relevance-driven ordering** — matching items always appear before non-matching items
3. **Tandem produces 3 documents** — a tandem application always generates exactly one combined tandem CV and one individual CV per partner
4. **Markdown output** — all CVs are output as Markdown suitable for conversion to PDF or DOCX
5. **Template-based** — use templates from `templates/` for consistent formatting
6. **Schema-validated sources** — only read from validated entity files in `kb/`
7. **Kebab-case output naming** — output file names use kebab-case
## Shared Modules
This skill depends on the following shared validation and utility modules:
- `src/schemas/validate.ts` — Entity validation (validate sources before generation)
- `src/schemas/types.ts` — TypeScript type definitions for all entity types
- `src/io/yaml-utils.ts` — YAML serialization/deserialization
- `src/io/entity-files.ts` — Entity file read management
## References
- `references/cv-formatting-guide.md` — formatting conventions for CV output
privat/CV/.kiro/skills/cv-generate/references/cv-formatting-guide.md
+135
View File
@@ -0,0 +1,135 @@
# CV Formatting Guide
Reference document for consistent CV formatting in generated output.
## Section Structure and Ordering
### Individual CV Sections
1. **Header** — Name, contact details, professional summary
2. **Professional Summary** — 2–4 sentence overview tailored to the target role
3. **Key Skills** — Grouped by category, most relevant to the posting listed first
4. **Professional Experience** — Reverse chronological, relevant roles expanded with achievements
5. **Projects** — Selected projects demonstrating relevant competencies
6. **Education** — Degrees and institutions
7. **Certifications** — Relevant certifications with issuer and date
8. **Languages** — Language proficiency levels
9. **Publications** — If applicable and relevant
### Tandem CV Sections
1. **Header** — Both partner names, "Job Sharing Tandem" label
2. **Tandem Introduction** — Shared vision and collaboration model
3. **Complementary Skills Overview** — How the partners' skills complement each other
4. **Joint Competencies** — Competencies the tandem brings together
5. **Partner A Profile** — Condensed individual profile (summary, key skills, top experiences)
6. **Partner B Profile** — Condensed individual profile (summary, key skills, top experiences)
7. **Combined Experience Timeline** — Merged chronological view of both partners' relevant experience
8. **Education & Certifications** — Combined list from both partners
## Formatting Conventions
### Dates
- Format: `MM/YYYY` (e.g., `04/2023`)
- Current/ongoing roles: `MM/YYYY – present`
- Date ranges: `MM/YYYY – MM/YYYY`
- Education with only years: `YYYY – YYYY`
### Skills
- Group by category: Programming Languages, Frameworks, Methodologies, Soft Skills, Domain Knowledge
- Within each category, list most relevant to the posting first
- Use the skill name exactly as stored in the knowledge base
- Include skill level only when it adds value (e.g., "Python (expert)")
### Experiences
- Format: **Role Title** | Organization | Date Range
- Follow with 2–4 bullet points highlighting achievements and responsibilities
- Prioritize achievements that match the job posting requirements
- Use action verbs at the start of each bullet point
### Achievements
- Start with an action verb (Led, Developed, Implemented, Designed, Managed)
- Include quantifiable results where available
- Keep each bullet to one or two sentences
### Projects
- Format: **Project Name** — Brief description
- Include technologies used and outcome/impact
- Only include projects relevant to the target posting
### Certifications
- Format: **Certification Name** — Issuer, Date
- Include expiry date if applicable: `(expires MM/YYYY)`
### Languages
- Format: Language — Level (e.g., "German — Native", "English — Fluent")
## Tandem-Specific Formatting
### Tandem Header
```markdown
# [Partner A Name] & [Partner B Name]
## Job Sharing Tandem Application
### [Target Role Title]
```
### Complementary Skills Presentation
Present as a two-column comparison or paired list showing how skills complement:
```markdown
| Area | Partner A | Partner B |
|------|-----------|-----------|
| Technical Leadership | Cloud architecture, AI/ML | Data engineering, DevOps |
| Management | Strategic planning | Operational execution |
```
### Collaboration Model
Describe the working arrangement in 2–3 sentences covering:
- How responsibilities are divided
- Communication and handoff approach
- Availability model (e.g., split days, alternating weeks)
## Markdown Output Guidelines
### Document Structure
- Use `#` for the CV title (person name or tandem names)
- Use `##` for major sections (Professional Experience, Skills, etc.)
- Use `###` for subsections (individual roles, project entries)
- Use `---` horizontal rules to separate major sections visually
### Text Formatting
- **Bold** for role titles, company names, and section emphasis
- *Italic* for dates and supplementary context
- Unordered lists (`-`) for achievements and skill lists
- Tables for structured comparisons (tandem skills, language levels)
### Whitespace
- One blank line between sections
- No trailing whitespace
- End file with a single newline
### Metadata Block
Include a YAML front matter block at the top of each generated CV:
```markdown
---
generated: YYYY-MM-DD
person: <person-id>
posting: <brief posting identifier>
type: individual | tandem
---
```
privat/CV/.kiro/skills/interview-collect/SKILL.md
+94
View File
@@ -0,0 +1,94 @@
---
name: interview-collect
description: Conducts focused interview sessions to collect and update knowledge in the personal knowledge base.
activation: manual
---
# interview-collect
Conducts focused interview sessions to collect and update knowledge in the personal knowledge base. Each session targets one topic area and asks up to 10 questions, writing collected data as YAML entity files.
## Activation
Activated by user request. Example triggers:
- "interview me"
- "collect knowledge"
- "let's do an interview session"
- "fill gaps in my profile"
## Inputs
- **Person ID** (optional): Which profile to interview for. Defaults to the primary profile if only one exists.
- **Topic area** (optional): A specific topic to focus on (e.g., a role, project, skill cluster). If not provided, the skill uses gap detection to choose the most valuable topic.
## Workflow
### 1. Load current state
- Read the target person profile from `kb/profiles/<person-id>.yaml`
- Read `kb/graph-index.yaml` to understand existing entities and relationships
- Read related entity files as needed for context
### 2. Detect gaps
- Use gap detection logic (`src/interview/gap-detection.ts`) to identify missing or incomplete attributes in the profile
- Prioritize gaps by importance: required fields first, then optional fields that improve completeness
- If the user specified a topic, scope gap detection to that topic area
### 3. Select session topic
- Choose ONE topic area for this session (e.g., a single role, a single project, a single skill cluster)
- Inform the user which topic area the session will cover and why
### 4. Conduct interview
- Ask focused questions one at a time, covering the selected topic area
- Maximum 10 questions per session — stop after 10 regardless of remaining gaps
- Adapt follow-up questions based on previous answers
- Accept "skip" or "I don't know" as valid responses — move to the next question
### 5. Detect conflicts
- Before persisting, use conflict detection logic (`src/interview/conflict-detection.ts`) to compare collected answers against existing data
- If conflicts are found: present both the existing value and the new value, ask the user which to keep
- Do not overwrite existing data without explicit user confirmation
### 6. Persist collected data
- Write new or updated entity files to the appropriate `kb/` subdirectory
- Use kebab-case file naming: `<entity-id>.yaml`
- Validate entities against schema before writing
- Update `kb/graph-index.yaml` with any new entities or relationships
### 7. Session summary
- Present a summary of what was collected and persisted
- List any remaining gaps that could be addressed in a future session
- Suggest the next topic area for a follow-up session
## Output
- New or updated YAML entity files in `kb/`
- Updated `kb/graph-index.yaml`
- Session summary with next-steps suggestion
## Shared Modules
This skill depends on the following shared validation and utility modules:
- `src/schemas/validate.ts` — Entity validation (validate before writing)
- `src/schemas/types.ts` — TypeScript type definitions for all entity types
- `src/io/yaml-utils.ts` — YAML serialization/deserialization
- `src/io/entity-files.ts` — Entity file read/write management
- `src/graph/index-manager.ts` — Graph index read/write and rebuild
## Rules and Constraints
1. **One topic per session** — do not mix unrelated topic areas in a single session
2. **Maximum 10 questions** — end the session after 10 questions even if gaps remain
3. **No fabrication** — only persist information explicitly provided by the user
4. **Conflict resolution required** — never silently overwrite existing data
5. **Schema validation** — validate all entities before writing to disk
6. **Kebab-case naming** — all entity file names use kebab-case
7. **Graph index sync** — update graph-index.yaml after every entity change
8. **Graceful interruption** — if the user stops early, persist whatever was collected so far
privat/CV/.kiro/skills/kb-review/SKILL.md
+95
View File
@@ -0,0 +1,95 @@
---
name: kb-review
description: Provides iterative knowledge base enhancement sessions with completeness scoring and prioritization.
activation: manual
---
# kb-review
Provides iterative knowledge base enhancement sessions. Calculates completeness scores per profile, identifies stale information, presents a prioritized review summary, and suggests areas for the next interview session and relationship additions for graph consistency.
## Activation
Activated by user request. Example triggers:
- "review my knowledge base"
- "what needs updating?"
- "run a KB review session"
- "check completeness of my profiles"
- "what's stale in my knowledge base?"
## Inputs
- **Person ID** (optional): Focus the review on a specific profile. If not provided, reviews all profiles.
- **Staleness threshold** (optional): Number of days since last modification to consider an entity stale. Defaults to 90 days.
## Workflow
### 1. Load all profiles and graph index
- Read all person profiles from `kb/profiles/`
- Read `kb/graph-index.yaml` to discover all entities and relationships
- Read entity files referenced by each profile (experiences, skills, organizations, projects, certifications, tandems)
### 2. Calculate completeness scores
- Use completeness scoring logic (`src/review/completeness-score.ts`) to compute a score per profile
- Score equals the ratio of filled attributes to total defined attributes, including relationship coverage
- A fully complete profile scores 1.0; an empty profile scores close to 0.0
### 3. Identify stale information
- Check the `modified` date on each entity file
- Flag entities where the time since last modification exceeds the staleness threshold
- Group stale entities by type and owning profile
### 4. Prioritize review areas
- Use prioritization logic (`src/review/prioritization.ts`) to rank entities
- Entities with lower completeness scores and older modification dates rank higher
- Required fields missing rank higher than optional fields missing
### 5. Present review summary
- Show per-profile completeness scores
- List stale entities grouped by profile
- Present the prioritized list of areas needing updates
- Highlight any broken references or graph inconsistencies found during loading
### 6. Suggest next interview topics
- Based on the prioritized list, recommend 1-3 topic areas for the next interview session
- Explain why each topic was selected (gap type, staleness, importance)
### 7. Recommend relationship additions
- Identify entities that exist but lack expected relationships in the graph index
- Suggest relationship additions that would improve graph consistency (e.g., a skill referenced in an experience but not linked to the person profile)
- Use valid relationship types: `has_skill`, `worked_at`, `collaborated_with`, `applied_for`, `partners_with`
## Output
- Review summary presented to the user (not written to a file)
- Prioritized list of areas needing updates
- Suggested interview topics for next session
- Recommended relationship additions
## Shared Modules
This skill depends on the following shared validation and utility modules:
- `src/schemas/validate.ts` — Entity validation (validate sources during review)
- `src/schemas/types.ts` — TypeScript type definitions for all entity types
- `src/io/yaml-utils.ts` — YAML serialization/deserialization
- `src/io/entity-files.ts` — Entity file read management
- `src/graph/index-manager.ts` — Graph index read and consistency checks
## Rules and Constraints
1. **Read-only** — this skill does not modify any entity files or the graph index; it only reads and reports
2. **No fabrication** — only report information derived from actual entity data
3. **Completeness formula** — score = filled attributes / total defined attributes (including relationship coverage)
4. **Staleness threshold** — default 90 days; configurable per invocation
5. **Prioritization** — lower completeness + older modification date = higher priority
6. **Valid relationship types only** — only suggest relationships from the defined set
7. **Schema-validated sources** — only read from validated entity files in `kb/`
8. **Actionable output** — every suggestion should be specific enough to act on in an interview session
privat/CV/.kiro/skills/linkedin-profile/SKILL.md
+167
View File
@@ -0,0 +1,167 @@
---
name: linkedin-profile
description: Generates optimized LinkedIn profile content, content strategy, and performance tracking from the personal knowledge base.
activation: manual
---
# linkedin-profile
Generates optimized LinkedIn profile content from the knowledge base. Produces headline variants, About section, experience descriptions, a quarterly content strategy, and performance tracking reports. Outputs Markdown files to `output/linkedin/`.
## Activation
Activated by user request for LinkedIn profile optimization, content strategy, or tracking. Example triggers:
- "optimize my LinkedIn profile"
- "generate LinkedIn headline variants"
- "create a content strategy for Q3"
- "update my LinkedIn tracking"
- "write my LinkedIn About section"
- "generate experience descriptions for LinkedIn"
## Inputs
- **personId** (required): Reference to a Person entity ID in `kb/profiles/`. Defaults to the primary profile if only one exists.
- **emphasis** (optional): Direction for headline generation — `dual-role`, `ai-expert`, or `leadership`. Defaults to `dual-role`.
- **tone** (optional): Tone for the About section — `nahbar`, `fachlich`, or `inspirierend`. Defaults to `nahbar`.
- **includeStats** (optional): Whether to include concrete numbers in the About section. Defaults to `true`.
- **quarter** (optional): Target quarter for content strategy, e.g. `2026-Q3`. Required for content strategy workflow.
- **existingFormats** (optional): Existing content formats to integrate (e.g. `podcast`, `column`). Used in content strategy generation.
- **experienceIds** (optional): Specific experience IDs to generate descriptions for. If omitted, generates for all experiences.
- **keywords** (optional): SEO keywords to include in experience descriptions.
- **variants** (optional): Number of headline variants to generate. Defaults to `3`.
## Workflows
### 1. Profile Generation
Generates optimized texts for Headline, About section, and Experience descriptions.
#### 1.1 Load person profile
- Read the target person profile from `kb/profiles/<personId>.yaml`
- Read `kb/graph-index.yaml` to discover related entities
- Load referenced experiences from `kb/experiences/`
- Load referenced skills from `kb/skills/`
- Load referenced projects from `kb/projects/`
#### 1.2 Generate Headline
- Use headline generation logic (`src/linkedin/headline-generator.ts`)
- Generate multiple variants (default: 3) with different emphasis
- Ensure both roles (DB InfraGO + Data Hive Cassel) are represented
- Validate against 220-character limit
- Include differentiating elements and relevant keywords
#### 1.3 Generate About Section
- Use About generation logic (`src/linkedin/about-generator.ts`)
- Structure into sections: Hook, Mission, Expertise, CTA
- Ensure hook is compelling in first 2 lines (before "mehr anzeigen")
- Include concrete stats (60+ publications, 13+ years AI, 50+ projects)
- Name three core themes (Innovation/Technology, People/Culture, Responsibility)
- Validate against 2,600-character limit
#### 1.4 Generate Experience Descriptions
- Use experience generation logic (`src/linkedin/experience-generator.ts`)
- Focus on results and impact, not task descriptions
- Include relevant keywords for LinkedIn search
- Highlight measurable achievements
- Position DB InfraGO as primary role, Data Hive with founder achievements
- Frame JobSharing experiment as leadership innovation
- Position academic career as AI expertise foundation
#### 1.5 Write Profile Output
- Combine all generated sections into `output/linkedin/profile-optimized.md`
- Include validation status and generation date
- Present variants to user for selection and refinement
### 2. Content Strategy
Generates a structured content plan for a given quarter.
#### 2.1 Analyze profile and themes
- Read person profile and identify core expertise areas
- Map expertise to content theme clusters
- Identify existing content formats (podcast, column) for integration
#### 2.2 Generate strategy
- Use content strategy logic (`src/linkedin/content-strategy.ts`)
- Define posting frequency (2 posts per week)
- Create theme clusters with weighting (Innovation 40%, People 35%, Responsibility 25%)
- Generate weekly posting plan with concrete time slots
- Define engagement routine (5+ comments/week on thought leaders)
- Specify format mix (text, carousel, video, newsletter)
- Integrate existing formats (Podcast "Almost Intelligent", Column "Kniepunkt")
#### 2.3 Write Strategy Output
- Write generated strategy to `output/linkedin/content-strategy.md`
- Structure as quarterly template that can be updated
### 3. Tracking
Records LinkedIn metrics and generates performance reports.
#### 3.1 Record metrics
- Use tracking logic (`src/linkedin/tracking-manager.ts`)
- Store tracking entries as YAML entities in `kb/tracking/`
- Record profile KPIs (views, search appearances, connection requests)
- Record post KPIs (impressions, engagement rate, comments, reposts)
#### 3.2 Generate reports
- Calculate weekly reports with week-over-week comparison
- Calculate monthly trend analysis with growth metrics
- Mark best-practice posts (above-average engagement rate)
- Derive data-driven recommendations for content optimization
#### 3.3 Write Tracking Output
- Write generated report to `output/linkedin/tracking-report.md`
- Include weekly and monthly summaries
- Highlight top-performing content and recommendations
## Outputs
- **Profile document**: `output/linkedin/profile-optimized.md` — Headline variants, About section, Experience descriptions with validation status
- **Content strategy**: `output/linkedin/content-strategy.md` — Quarterly posting plan, theme clusters, engagement routine, format mix
- **Tracking report**: `output/linkedin/tracking-report.md` — Weekly/monthly metrics, trends, best practices, recommendations
## Shared Modules
This skill depends on the following shared validation and utility modules:
- `src/schemas/validate.ts` — Entity validation (validate sources before generation)
- `src/schemas/types.ts` — TypeScript type definitions for all entity types
- `src/io/yaml-utils.ts` — YAML serialization/deserialization
- `src/io/entity-files.ts` — Entity file read management
## Source Modules
The skill orchestrates the following LinkedIn-specific modules:
- `src/linkedin/headline-generator.ts` — Headline variant generation with keyword extraction
- `src/linkedin/about-generator.ts` — About section generation with structured sections
- `src/linkedin/experience-generator.ts` — Experience description generation with achievement focus
- `src/linkedin/content-strategy.ts` — Content strategy and posting plan generation
- `src/linkedin/tracking-manager.ts` — Metrics tracking, reporting, and trend analysis
- `src/linkedin/constraints.ts` — LinkedIn-specific constraint validation (character limits)
- `src/linkedin/types.ts` — TypeScript interfaces for all LinkedIn modules
## Rules and Constraints
1. **KB as source of truth** — all profile content is generated exclusively from knowledge base entities; never invent credentials, achievements, or stats
2. **Character limits enforced** — Headline max 220 characters, About max 2,600 characters; validated programmatically at generation time
3. **Dual-role representation** — Headline and About must represent both roles (DB InfraGO + Data Hive Cassel)
4. **Results over tasks** — Experience descriptions focus on impact and measurable outcomes, not job duties
5. **No jargon** — Headline and About must be understandable for a broad business audience
6. **Three core themes** — Content must map to Innovation/Technology, People/Culture, or Responsibility
7. **Markdown output** — all outputs as Markdown suitable for direct use
8. **Schema-validated sources** — only read from validated entity files in `kb/`
9. **Tracking as YAML entities** — metrics stored in `kb/tracking/` following KB conventions (kebab-case keys, ISO dates)
10. **Iterative refinement** — present generated content to user for feedback and allow interactive adjustments
privat/CV/.kiro/skills/talk-intro/SKILL.md
+90
View File
@@ -0,0 +1,90 @@
---
name: talk-intro
description: Generates speaker introductions for talks and events in three length variants.
activation: manual
---
# talk-intro
Generates speaker introductions for talks and events. Produces three length variants (short, medium, long) adapted to the event context. Outputs Markdown files to `output/intros/`.
## Activation
Activated by user request with a talk topic and event context. Example triggers:
- "write a speaker intro for my talk on [topic]"
- "generate an introduction for [event]"
- "I need a speaker bio for [conference]"
- "create a talk introduction"
## Inputs
- **Talk topic** (required): The subject of the talk or presentation.
- **Event context** (required): The type of event — technical conference, business meeting, or academic setting. Used to adapt tone and emphasis.
- **Person ID** (optional): Which profile to generate the introduction for. Defaults to the primary profile if only one exists.
- **Output filename prefix** (optional): Custom prefix for output files. Defaults to `<person-id>-<event-slug>-<date>`.
## Workflow
### 1. Load person profile
- Read the target person profile from `kb/profiles/<person-id>.yaml`
- Read `kb/graph-index.yaml` to discover related entities
- Load referenced skills from `kb/skills/`
- Load referenced experiences from `kb/experiences/`
- Load referenced projects from `kb/projects/`
### 2. Identify relevant expertise
- Use introduction generation logic (`src/intro/intro-generator.ts`) to select expertise relevant to the talk topic
- Match skills, experiences, and projects that relate to the talk subject
- Prioritize recent and high-level expertise
### 3. Determine tone
- Adapt tone based on event context:
- **Technical conference** — emphasize technical skills, open source contributions, hands-on experience, specific technologies
- **Business meeting** — emphasize leadership, strategic impact, organizational achievements, business outcomes
- **Academic setting** — emphasize research, publications, methodology, teaching, formal credentials
- Select vocabulary and sentence structure appropriate to the context
### 4. Generate length variants
- **Short** (2-3 sentences): Name, current role, and one key qualification relevant to the talk topic
- **Medium** (one paragraph): Expanded context including relevant experience, notable achievements, and connection to the talk topic
- **Long** (multiple paragraphs): Full professional narrative relevant to the talk, including career arc, specific projects, and expertise depth
### 5. Apply template
- Apply the speaker introduction template (`templates/intro-speaker.md`)
- Fill in all three length variants
- Include metadata (person, topic, event context, generation date)
### 6. Write output
- Write the generated introduction to `output/intros/<prefix>.md`
- Present all three variants to the user for selection
## Output
- Speaker introduction file: `output/intros/<prefix>.md`
- Contains short, medium, and long variants in a single file
## Shared Modules
This skill depends on the following shared validation and utility modules:
- `src/schemas/validate.ts` — Entity validation (validate sources before generation)
- `src/schemas/types.ts` — TypeScript type definitions for all entity types
- `src/io/yaml-utils.ts` — YAML serialization/deserialization
- `src/io/entity-files.ts` — Entity file read management
## Rules and Constraints
1. **No fabrication** — only include information present in the knowledge base; never invent credentials or achievements
2. **Three variants required** — always produce short, medium, and long variants
3. **Length ordering** — short < medium < long in character count
4. **Topic relevance** — emphasize expertise related to the talk topic
5. **Tone adaptation** — adjust language and emphasis to match event context
6. **Markdown output** — output as Markdown suitable for direct use
7. **Template-based** — use `templates/intro-speaker.md` for consistent formatting
8. **Schema-validated sources** — only read from validated entity files in `kb/`