TypeScript Usage Guide

# Initialize a new mono repo
cldpm init my-monorepo
 
# Create projects and components
cldpm create project web-app
cldpm create skill logging
 
# Add components to projects
cldpm add skill:logging --to web-app
 
# Link dependencies between components
cldpm link skill:utils --to skill:logging
 
# View project structure
cldpm get web-app --format tree
 
# Download project with all dependencies
cldpm get web-app --download --output ./standalone
 
# Download from remote repository
cldpm get web-app -r owner/repo --download
 
# Sync symlinks after git clone
cldpm sync --all

import {
  // Config
  loadCldpmConfig,
  saveCldpmConfig,
  loadProjectConfig,
  saveProjectConfig,
  listProjects,
 
  // Resolver
  resolveProject,
  listSharedComponents,
  resolveComponentDependencies,
 
  // Linker
  syncProjectLinks,
  addComponentLink,
 
  // Schemas
  createCldpmConfig,
  createProjectConfig,
 
  // Types
  type CldpmConfig,
  type ProjectConfig,
  type ResolvedProject,
} from "cldpm";

import { loadCldpmConfig } from "cldpm";
 
const config = await loadCldpmConfig("/path/to/monorepo");
 
console.log(config.name);        // "my-monorepo"
console.log(config.projectsDir); // "projects"
console.log(config.sharedDir);   // "shared"

import { loadProjectConfig } from "cldpm";
 
const project = await loadProjectConfig("/path/to/project");
 
console.log(project.name);
console.log(project.dependencies.skills);

import { listProjects } from "cldpm";
 
const projects = await listProjects("/path/to/monorepo");
 
for (const project of projects) {
  console.log(`${project.name}: ${project.path}`);
}

import { listSharedComponents } from "cldpm";
 
const components = await listSharedComponents("/path/to/monorepo");
 
console.log("Skills:", components.skills);
console.log("Agents:", components.agents);
console.log("Hooks:", components.hooks);
console.log("Rules:", components.rules);

import { resolveProject } from "cldpm";
 
const project = await resolveProject("my-project", "/path/to/monorepo");
 
// Project info
console.log(project.name);
console.log(project.path);
 
// Shared components
for (const skill of project.shared.skills) {
  console.log(`Shared skill: ${skill.name}`);
  console.log(`  Source: ${skill.sourcePath}`);
  console.log(`  Files: ${skill.files.join(", ")}`);
}
 
// Local components
for (const skill of project.local.skills) {
  console.log(`Local skill: ${skill.name}`);
}

import { syncProjectLinks, getProjectPath } from "cldpm";
 
const projectPath = await getProjectPath("my-project", repoRoot);
if (!projectPath) {
  throw new Error("Project not found");
}
 
const result = await syncProjectLinks(projectPath, repoRoot);
 
console.log("Created:", result.created);
console.log("Missing:", result.missing);

import { addComponentLink } from "cldpm";
 
const success = await addComponentLink(
  projectPath,
  "skills",
  "logging",
  repoRoot
);
 
if (success) {
  console.log("Link created");
}

import { resolveComponentDependencies } from "cldpm";
 
const deps = await resolveComponentDependencies(
  "skills",
  "advanced-review",
  repoRoot
);
 
for (const [type, name] of deps) {
  console.log(`${type}/${name}`);
}

import { getAllDependenciesForComponent } from "cldpm";
 
const deps = await getAllDependenciesForComponent(
  "agents",
  "debugger",
  repoRoot
);
 
console.log("Required skills:", deps.skills);
console.log("Required hooks:", deps.hooks);

import { createCldpmConfig, saveCldpmConfig } from "cldpm";
 
const config = createCldpmConfig("my-repo", {
  version: "1.0.0",
  projectsDir: "projects",
  sharedDir: "shared",
});
 
await saveCldpmConfig(config, "/path/to/repo");

import {
  createProjectConfig,
  createProjectDependencies,
  saveProjectConfig,
} from "cldpm";
 
const config = createProjectConfig("my-project", {
  description: "My project",
  dependencies: createProjectDependencies({
    skills: ["logging", "utils"],
    agents: ["debugger"],
  }),
});
 
await saveProjectConfig(config, "/path/to/project");

import { loadCldpmConfig } from "cldpm";
 
try {
  const config = await loadCldpmConfig("/path/to/repo");
} catch (error) {
  if (error instanceof Error) {
    console.error(`Failed to load config: ${error.message}`);
  }
}

import type {
  CldpmConfig,
  ProjectConfig,
  ProjectDependencies,
  ComponentMetadata,
  ComponentDependencies,
  ComponentType,
  ResolvedComponent,
  ResolvedProject,
} from "cldpm";
 
// Use types for better IDE support
function processProject(project: ResolvedProject): void {
  for (const skill of project.shared.skills) {
    console.log(skill.name);
  }
}